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

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

@@ -0,0 +1,757 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areAllModelsVisible = exports.toggleModels = exports.invertAllModels = exports.hideAllModels = exports.showAllModels = exports.createModelsTreeVisibilityHandler = exports.ELEMENT_CLASS_NAME = exports.CATEGORY_CLASS_NAME = exports.MODEL_CLASS_NAME = exports.SUBJECT_CLASS_NAME = void 0;
+const rxjs_1 = require("rxjs");
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_frontend_1 = require("@itwin/core-frontend");
+const presentation_hierarchies_1 = require("@itwin/presentation-hierarchies");
+const CategoriesVisibilityUtils_1 = require("../../common/CategoriesVisibilityUtils");
+const Rxjs_1 = require("../../common/Rxjs");
+const AlwaysAndNeverDrawnElementInfo_1 = require("./AlwaysAndNeverDrawnElementInfo");
+const ModelsTreeNode_1 = require("./ModelsTreeNode");
+const Tooltip_1 = require("./Tooltip");
+const VisibilityChangeEventListener_1 = require("./VisibilityChangeEventListener");
+exports.SUBJECT_CLASS_NAME = "BisCore.Subject";
+exports.MODEL_CLASS_NAME = "BisCore.GeometricModel3d";
+exports.CATEGORY_CLASS_NAME = "BisCore.SpatialCategory";
+exports.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
+ */
+function createModelsTreeVisibilityHandler(props) {
+    return new ModelsTreeVisibilityHandlerImpl(props);
+}
+exports.createModelsTreeVisibilityHandler = createModelsTreeVisibilityHandler;
+class ModelsTreeVisibilityHandlerImpl {
+    constructor(_props) {
+        this._props = _props;
+        this._eventListener = (0, VisibilityChangeEventListener_1.createVisibilityChangeEventListener)(_props.viewport);
+        this._alwaysAndNeverDrawnElements = new AlwaysAndNeverDrawnElementInfo_1.AlwaysAndNeverDrawnElementInfo(_props.viewport);
+        this._idsCache = this._props.idsCache;
+    }
+    // istanbul ignore next
+    get onVisibilityChange() {
+        return this._eventListener.onVisibilityChange;
+    }
+    async getVisibilityStatus(node) {
+        return (0, rxjs_1.firstValueFrom)(this.getVisibilityStatusObs(node));
+    }
+    async changeVisibility(node, shouldDisplay) {
+        return (0, Rxjs_1.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 (presentation_hierarchies_1.HierarchyNode.isClassGroupingNode(node)) {
+            return this.getClassGroupingNodeDisplayStatus(node);
+        }
+        if (!presentation_hierarchies_1.HierarchyNode.isInstancesNode(node)) {
+            return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("disabled"));
+        }
+        if (ModelsTreeNode_1.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_1.ModelsTreeNode.isModelNode(node)) {
+            return this.getModelVisibilityStatus(node.key.instanceKeys[0].id);
+        }
+        const modelId = ModelsTreeNode_1.ModelsTreeNode.getModelId(node);
+        if (!modelId) {
+            return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("disabled"));
+        }
+        if (ModelsTreeNode_1.ModelsTreeNode.isCategoryNode(node)) {
+            return this.getCategoryDisplayStatus({
+                categoryId: node.key.instanceKeys[0].id,
+                modelId,
+            });
+        }
+        const categoryId = ModelsTreeNode_1.ModelsTreeNode.getCategoryId(node);
+        if (!categoryId) {
+            return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("disabled"));
+        }
+        return this.getElementDisplayStatus({
+            elementId: node.key.instanceKeys[0].id,
+            modelId,
+            categoryId,
+        });
+    }
+    getFilteredNodeVisibility({ parentKeys, filterPaths }) {
+        return (0, rxjs_1.from)(this.getFilterTargets({ parentKeys, filterPaths })).pipe((0, rxjs_1.mergeMap)(({ subjects, models, categories, elements }) => {
+            const observables = new Array();
+            if (subjects?.size) {
+                observables.push(this.getSubjectNodeVisibilityStatus([...subjects]));
+            }
+            if (models?.size) {
+                observables.push((0, rxjs_1.from)(models).pipe((0, rxjs_1.mergeMap)((modelId) => this.getModelVisibilityStatus(modelId))));
+            }
+            if (categories?.size) {
+                observables.push((0, rxjs_1.from)(categories).pipe((0, rxjs_1.mergeMap)((key) => {
+                    const { modelId, categoryId } = parseCategoryKey(key);
+                    return this.getCategoryDisplayStatus({ modelId, categoryId });
+                })));
+            }
+            if (elements?.size) {
+                observables.push((0, rxjs_1.from)(elements).pipe((0, rxjs_1.mergeMap)((key) => {
+                    const { modelId, categoryId, elementId } = parseElementKey(key);
+                    return this.getElementDisplayStatus({ modelId, categoryId, elementId });
+                })));
+            }
+            return (0, rxjs_1.merge)(...observables);
+        }), (0, rxjs_1.map)((x) => x.state), getVisibilityFromTreeNodeChildren, (0, rxjs_1.map)((x) => {
+            (0, core_bentley_1.assert)(x !== "empty");
+            return (0, Tooltip_1.createVisibilityStatus)(x);
+        }));
+    }
+    getSubjectNodeVisibilityStatus(subjectIds) {
+        const result = (0, rxjs_1.defer)(() => {
+            if (!this._props.viewport.view.isSpatialView()) {
+                return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("disabled", "subject.nonSpatialView"));
+            }
+            return (0, rxjs_1.from)(this._idsCache.getSubjectModelIds(subjectIds)).pipe((0, rxjs_1.concatAll)(), (0, rxjs_1.distinct)(), (0, rxjs_1.mergeMap)((modelId) => this.getModelVisibilityStatus(modelId)), (0, rxjs_1.map)((x) => x.state), getVisibilityStatusFromTreeNodeChildren({
+                visible: "subject.allModelsVisible",
+                hidden: "subject.allModelsHidden",
+                partial: "subject.someModelsHidden",
+            }));
+        });
+        const ovr = this._props.overrides?.getSubjectNodeVisibility;
+        return ovr ? (0, rxjs_1.from)(ovr(this.createOverrideProps({ ids: subjectIds }, result))) : result;
+    }
+    getModelVisibilityStatus(modelId) {
+        const result = (0, rxjs_1.defer)(() => {
+            const viewport = this._props.viewport;
+            if (!viewport.view.isSpatialView()) {
+                return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("disabled", "model.nonSpatialView"));
+            }
+            if (!viewport.view.viewsModel(modelId)) {
+                return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("hidden", "model.hiddenThroughModelSelector"));
+            }
+            return (0, rxjs_1.from)(this._idsCache.getModelCategories(modelId)).pipe((0, rxjs_1.concatAll)(), (0, rxjs_1.mergeMap)((categoryId) => this.getCategoryDisplayStatus({ modelId, categoryId })), (0, rxjs_1.map)((x) => x.state), getVisibilityFromTreeNodeChildren, (0, rxjs_1.map)((visibilityByCategories) => {
+                const state = visibilityByCategories === "empty" ? "visible" : visibilityByCategories;
+                return (0, Tooltip_1.createVisibilityStatus)(state, state === "partial" ? "model.someCategoriesHidden" : `model.allCategories${state ? "Visible" : "Hidden"}`);
+            }));
+        });
+        const ovr = this._props.overrides?.getModelDisplayStatus;
+        return ovr ? (0, rxjs_1.from)(ovr(this.createOverrideProps({ id: modelId }, result))) : result;
+    }
+    getDefaultCategoryVisibilityStatus({ modelId, categoryId }) {
+        const viewport = this._props.viewport;
+        if (!viewport.view.viewsModel(modelId)) {
+            return (0, Tooltip_1.createVisibilityStatus)("hidden", "category.hiddenThroughModel");
+        }
+        switch (this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId)) {
+            case core_frontend_1.PerModelCategoryVisibility.Override.Show:
+                return (0, Tooltip_1.createVisibilityStatus)("visible", "category.displayedThroughPerModelOverride");
+            case core_frontend_1.PerModelCategoryVisibility.Override.Hide:
+                return (0, Tooltip_1.createVisibilityStatus)("hidden", "category.hiddenThroughPerModelOverride");
+        }
+        const isVisible = viewport.view.viewsCategory(categoryId);
+        return isVisible
+            ? (0, Tooltip_1.createVisibilityStatus)("visible", "category.displayedThroughCategorySelector")
+            : (0, Tooltip_1.createVisibilityStatus)("hidden", "category.hiddenThroughCategorySelector");
+    }
+    getCategoryDisplayStatus(props) {
+        const result = (0, rxjs_1.defer)(() => {
+            if (!this._props.viewport.view.viewsModel(props.modelId)) {
+                return (0, rxjs_1.of)((0, Tooltip_1.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 ? (0, rxjs_1.from)(ovr(this.createOverrideProps(props, result))) : result;
+    }
+    getClassGroupingNodeDisplayStatus(node) {
+        const result = (0, rxjs_1.defer)(() => {
+            const info = this.getGroupingNodeInfo(node);
+            const { modelId, categoryId, elementIds } = info;
+            if (!this._props.viewport.view.viewsModel(modelId)) {
+                return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("hidden"));
+            }
+            return this.getVisibilityFromAlwaysAndNeverDrawnElements({
+                elements: elementIds,
+                defaultStatus: () => {
+                    const status = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId });
+                    return (0, Tooltip_1.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 ? (0, rxjs_1.from)(ovr(this.createOverrideProps({ node }, result))) : result;
+    }
+    getElementOverriddenVisibility(elementId) {
+        const viewport = this._props.viewport;
+        if (viewport.neverDrawn?.has(elementId)) {
+            return (0, Tooltip_1.createVisibilityStatus)("hidden", "element.hiddenThroughNeverDrawnList");
+        }
+        if (viewport.alwaysDrawn?.size) {
+            if (viewport.alwaysDrawn.has(elementId)) {
+                return (0, Tooltip_1.createVisibilityStatus)("visible", "element.displayedThroughAlwaysDrawnList");
+            }
+            if (viewport.isAlwaysDrawnExclusive) {
+                return (0, Tooltip_1.createVisibilityStatus)("hidden", "element.hiddenDueToOtherElementsExclusivelyAlwaysDrawn");
+            }
+        }
+        return undefined;
+    }
+    getElementDisplayStatus(props) {
+        const result = (0, rxjs_1.defer)(() => {
+            const viewport = this._props.viewport;
+            const { elementId, modelId, categoryId } = props;
+            if (!viewport.view.viewsModel(modelId)) {
+                return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("hidden", "element.hiddenThroughModel"));
+            }
+            let status = this.getElementOverriddenVisibility(elementId);
+            if (status) {
+                return (0, rxjs_1.of)(status);
+            }
+            status = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId });
+            return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)(status.state, status.state === "visible" ? undefined : "element.hiddenThroughCategory"));
+        });
+        const ovr = this._props.overrides?.getElementDisplayStatus;
+        return ovr ? (0, rxjs_1.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 (presentation_hierarchies_1.HierarchyNode.isClassGroupingNode(node)) {
+            return this.changeElementGroupingNodeState(node, on);
+        }
+        // istanbul ignore if
+        if (!presentation_hierarchies_1.HierarchyNode.isInstancesNode(node)) {
+            return rxjs_1.EMPTY;
+        }
+        if (ModelsTreeNode_1.ModelsTreeNode.isSubjectNode(node)) {
+            return this.changeSubjectNodeState(node.key.instanceKeys.map((key) => key.id), on);
+        }
+        if (ModelsTreeNode_1.ModelsTreeNode.isModelNode(node)) {
+            return this.changeModelState({ ids: node.key.instanceKeys[0].id, on });
+        }
+        const modelId = ModelsTreeNode_1.ModelsTreeNode.getModelId(node);
+        // istanbul ignore if
+        if (!modelId) {
+            return rxjs_1.EMPTY;
+        }
+        if (ModelsTreeNode_1.ModelsTreeNode.isCategoryNode(node)) {
+            return this.changeCategoryState({
+                categoryId: node.key.instanceKeys[0].id,
+                modelId,
+                on,
+            });
+        }
+        const categoryId = ModelsTreeNode_1.ModelsTreeNode.getCategoryId(node);
+        // istanbul ignore if
+        if (!categoryId) {
+            // istanbul ignore next
+            return rxjs_1.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 (!presentation_hierarchies_1.HierarchyNodeIdentifier.isInstanceNodeIdentifier(target)) {
+                return;
+            }
+            const previousPath = path.slice(0, path.length - 1);
+            if (await imodelAccess.classDerivesFrom(target.className, exports.SUBJECT_CLASS_NAME)) {
+                addFilterTarget("subjects", target.id);
+                return;
+            }
+            if (await imodelAccess.classDerivesFrom(target.className, exports.MODEL_CLASS_NAME)) {
+                addFilterTarget("models", target.id);
+                return;
+            }
+            if (await imodelAccess.classDerivesFrom(target.className, exports.CATEGORY_CLASS_NAME)) {
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+                const modelId = await this.findClassIdInFilterPath(previousPath, parentKeys, exports.MODEL_CLASS_NAME);
+                addFilterTarget("categories", createCategoryKey(modelId, target.id));
+                return;
+            }
+            const [modelId, categoryId] = await Promise.all([
+                this.findClassIdInFilterPath(previousPath, parentKeys, exports.MODEL_CLASS_NAME),
+                this.findClassIdInFilterPath(previousPath, parentKeys, exports.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 (!presentation_hierarchies_1.HierarchyNodeIdentifier.isInstanceNodeIdentifier(pathIdentifier)) {
+                    continue;
+                }
+                if (!(await imodelAccess.classDerivesFrom(pathIdentifier.className, exports.ELEMENT_CLASS_NAME))) {
+                    break;
+                }
+                addFilterTarget("elements", createElementKey(modelId, categoryId, pathIdentifier.id));
+            }
+        }));
+        return filterTargets;
+    }
+    changeFilteredNodeVisibility({ on, ...props }) {
+        return (0, rxjs_1.from)(this.getFilterTargets(props)).pipe((0, rxjs_1.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((0, rxjs_1.from)(categories).pipe((0, rxjs_1.mergeMap)((key) => {
+                    const { modelId, categoryId } = parseCategoryKey(key);
+                    return this.changeCategoryState({ modelId, categoryId, on });
+                })));
+            }
+            if (elements?.size) {
+                observables.push((0, rxjs_1.from)(elements).pipe((0, rxjs_1.mergeMap)((key) => {
+                    const { modelId, categoryId, elementId } = parseElementKey(key);
+                    return this.changeElementState({ modelId, categoryId, elementId, on });
+                })));
+            }
+            return (0, rxjs_1.merge)(...observables);
+        }));
+    }
+    changeSubjectNodeState(ids, on) {
+        const result = (0, rxjs_1.defer)(() => {
+            // istanbul ignore if
+            if (!this._props.viewport.view.isSpatialView()) {
+                return rxjs_1.EMPTY;
+            }
+            return (0, rxjs_1.from)(this._idsCache.getSubjectModelIds(ids)).pipe((0, rxjs_1.mergeMap)((modelIds) => this.changeModelState({ ids: modelIds, on })));
+        });
+        const ovr = this._props.overrides?.changeSubjectNodeState;
+        return ovr ? (0, rxjs_1.from)(ovr(this.createVoidOverrideProps({ ids, on }, result))) : result;
+    }
+    changeModelState(props) {
+        const result = (0, rxjs_1.defer)(() => {
+            const viewport = this._props.viewport;
+            // istanbul ignore if
+            if (!viewport.view.isSpatialView()) {
+                return rxjs_1.EMPTY;
+            }
+            const { ids, on } = props;
+            if (!on) {
+                viewport.changeModelDisplay(ids, false);
+                return rxjs_1.EMPTY;
+            }
+            return (0, rxjs_1.concat)((0, rxjs_1.defer)(() => {
+                viewport.perModelCategoryVisibility.clearOverrides(ids);
+                return (0, rxjs_1.from)(viewport.addViewedModels(ids));
+            }), (typeof ids === "string" ? (0, rxjs_1.of)(ids) : (0, rxjs_1.from)(ids)).pipe((0, rxjs_1.mergeMap)((modelId) => {
+                return (0, rxjs_1.from)(this._idsCache.getModelCategories(modelId)).pipe((0, rxjs_1.concatAll)(), (0, rxjs_1.mergeMap)((categoryId) => this.changeCategoryState({ categoryId, modelId, on: true })));
+            })));
+        });
+        const ovr = this._props.overrides?.changeModelState;
+        return ovr ? (0, rxjs_1.from)(ovr(this.createVoidOverrideProps(props, result))) : result;
+    }
+    showModelWithoutAnyCategoriesOrElements(modelId) {
+        const viewport = this._props.viewport;
+        return (0, rxjs_1.forkJoin)({
+            categories: this._idsCache.getModelCategories(modelId),
+            alwaysDrawnElements: this.getAlwaysDrawnElements({ modelId }),
+        }).pipe((0, rxjs_1.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
+            ? core_frontend_1.PerModelCategoryVisibility.Override.None
+            : on
+                ? core_frontend_1.PerModelCategoryVisibility.Override.Show
+                : core_frontend_1.PerModelCategoryVisibility.Override.Hide;
+        viewport.perModelCategoryVisibility.setOverride(modelId, categoryId, override);
+        if (override === core_frontend_1.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 = (0, rxjs_1.defer)(() => {
+            const viewport = this._props.viewport;
+            const { modelId, categoryId, on } = props;
+            return (0, rxjs_1.concat)(props.on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : rxjs_1.EMPTY, (0, rxjs_1.defer)(() => {
+                this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, on);
+                return this.clearAlwaysAndNeverDrawnElements(props);
+            }));
+        });
+        const ovr = this._props.overrides?.changeCategoryState;
+        return ovr ? (0, rxjs_1.from)(ovr(this.createVoidOverrideProps(props, result))) : result;
+    }
+    /**
+     * Updates visibility of all grouping node's elements.
+     * @see `changeElementState`
+     */
+    changeElementGroupingNodeState(node, on) {
+        const result = (0, rxjs_1.defer)(() => {
+            const info = this.getGroupingNodeInfo(node);
+            const { modelId, categoryId, elementIds } = info;
+            const viewport = this._props.viewport;
+            return (0, rxjs_1.concat)(on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : rxjs_1.EMPTY, (0, rxjs_1.defer)(() => {
+                const categoryVisibility = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId });
+                const isDisplayedByDefault = categoryVisibility.state === "visible";
+                return (0, rxjs_1.from)(elementIds).pipe(this.changeElementStateNoChildrenOperator({ on, isDisplayedByDefault }));
+            }));
+        });
+        const ovr = this._props.overrides?.changeElementGroupingNodeState;
+        return ovr ? (0, rxjs_1.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 = (0, rxjs_1.defer)(() => {
+            const { elementId, on, modelId, categoryId } = props;
+            const viewport = this._props.viewport;
+            return (0, rxjs_1.concat)(props.on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : rxjs_1.EMPTY, (0, rxjs_1.defer)(() => {
+                const categoryVisibility = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId });
+                const isDisplayedByDefault = categoryVisibility.state === "visible";
+                return (0, rxjs_1.of)(elementId).pipe(this.changeElementStateNoChildrenOperator({ on, isDisplayedByDefault }));
+            }));
+        });
+        const ovr = this._props.overrides?.changeElementState;
+        return ovr ? (0, rxjs_1.from)(ovr(this.createVoidOverrideProps(props, result))) : result;
+    }
+    changeElementStateNoChildrenOperator(props) {
+        return (elementIds) => {
+            const { on, isDisplayedByDefault } = props;
+            const isAlwaysDrawnExclusive = this._props.viewport.isAlwaysDrawnExclusive;
+            return elementIds.pipe((0, rxjs_1.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 || []),
+            }), (0, rxjs_1.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 (0, Tooltip_1.createVisibilityStatus)("hidden", props.tooltips.allElementsInNeverDrawnList);
+        }
+        if (alwaysDrawn?.size === totalCount) {
+            return (0, Tooltip_1.createVisibilityStatus)("visible", props.tooltips.allElementsInAlwaysDrawnList);
+        }
+        const viewport = this._props.viewport;
+        if (viewport.isAlwaysDrawnExclusive && viewport.alwaysDrawn?.size) {
+            return alwaysDrawn?.size
+                ? (0, Tooltip_1.createVisibilityStatus)("partial", props.tooltips.elementsInBothAlwaysAndNeverDrawn)
+                : (0, Tooltip_1.createVisibilityStatus)("hidden", props.tooltips.noElementsInExclusiveAlwaysDrawnList);
+        }
+        const status = props.defaultStatus();
+        if ((status.state === "visible" && neverDrawn?.size) || (status.state === "hidden" && alwaysDrawn?.size)) {
+            return (0, Tooltip_1.createVisibilityStatus)("partial");
+        }
+        return status;
+    }
+    getVisibilityFromAlwaysAndNeverDrawnElements(props) {
+        const viewport = this._props.viewport;
+        if (viewport.isAlwaysDrawnExclusive) {
+            if (!viewport?.alwaysDrawn?.size) {
+                return (0, rxjs_1.of)((0, Tooltip_1.createVisibilityStatus)("hidden", props.tooltips.noElementsInExclusiveAlwaysDrawnList));
+            }
+        }
+        else if (!viewport?.neverDrawn?.size && !viewport?.alwaysDrawn?.size) {
+            return (0, rxjs_1.of)(props.defaultStatus());
+        }
+        if ("elements" in props) {
+            return (0, rxjs_1.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 (0, rxjs_1.forkJoin)({
+            totalCount,
+            alwaysDrawn: this.getAlwaysDrawnElements(props.queryProps),
+            neverDrawn: this.getNeverDrawnElements(props.queryProps),
+        }).pipe((0, rxjs_1.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 (0, rxjs_1.forkJoin)({
+            alwaysDrawn: this.getAlwaysDrawnElements(props),
+            neverDrawn: this.getNeverDrawnElements(props),
+        }).pipe((0, rxjs_1.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 () => (0, Rxjs_1.toVoidPromise)(obs),
+            handler: this,
+        };
+    }
+    createOverrideProps(props, obs) {
+        return {
+            ...props,
+            originalImplementation: async () => (0, rxjs_1.firstValueFrom)(obs),
+            handler: this,
+        };
+    }
+    getGroupingNodeInfo(node) {
+        const modelId = ModelsTreeNode_1.ModelsTreeNode.getModelId(node);
+        const categoryId = ModelsTreeNode_1.ModelsTreeNode.getCategoryId(node);
+        (0, core_bentley_1.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 (presentation_hierarchies_1.HierarchyNodeIdentifier.isInstanceNodeIdentifier(id)) {
+                    yield id;
+                }
+            }
+            for (let i = parentKeys.length - 1; i >= 0; --i) {
+                const key = parentKeys[i];
+                if (presentation_hierarchies_1.HierarchyNodeKey.isInstances(key)) {
+                    yield* key.instanceKeys;
+                }
+            }
+        }
+        for (const parentKey of keysToCheck()) {
+            if (await this._props.imodelAccess.classDerivesFrom(parentKey.className, className)) {
+                return parentKey.id;
+            }
+        }
+        (0, core_bentley_1.assert)(false, () => `Cannot find an instance of ${className} in instance keys: ${JSON.stringify([...keysToCheck()], undefined, 2)}`);
+    }
+}
+function getVisibilityFromTreeNodeChildren(obs) {
+    return obs.pipe((0, Rxjs_1.reduceWhile)((x) => x.allVisible || x.allHidden, (acc, val) => {
+        acc.allVisible &&= val === "visible";
+        acc.allHidden &&= val === "hidden";
+        return acc;
+    }, { allVisible: true, allHidden: true }), (0, rxjs_1.map)((x) => {
+        if (!x) {
+            return "empty";
+        }
+        return x.allVisible ? "visible" : x.allHidden ? "hidden" : "partial";
+    }));
+}
+function getVisibilityStatusFromTreeNodeChildren(tooltipMap) {
+    return (obs) => {
+        return getVisibilityFromTreeNodeChildren(obs).pipe((0, rxjs_1.map)((visibility) => {
+            if (visibility === "empty") {
+                visibility = "visible";
+            }
+            return (0, Tooltip_1.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 (!presentation_hierarchies_1.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
+ */
+async function showAllModels(models, viewport) {
+    await viewport.addViewedModels(models);
+    viewport.clearNeverDrawn();
+    viewport.clearAlwaysDrawn();
+    await (0, CategoriesVisibilityUtils_1.toggleAllCategories)(core_frontend_1.IModelApp.viewManager, viewport.iModel, true, viewport, false);
+}
+exports.showAllModels = showAllModels;
+/**
+ * Disables display of all given models.
+ * @public
+ */
+async function hideAllModels(models, viewport) {
+    viewport.changeModelDisplay(models, false);
+}
+exports.hideAllModels = hideAllModels;
+/**
+ * Inverts display of all given models.
+ * @public
+ */
+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);
+}
+exports.invertAllModels = invertAllModels;
+/**
+ * Based on the value of `enable` argument, either enables or disables display of given models.
+ * @public
+ */
+async function toggleModels(models, enable, viewport) {
+    // istanbul ignore if
+    if (!models) {
+        return;
+    }
+    if (enable) {
+        viewport.changeModelDisplay(models, false);
+    }
+    else {
+        await viewport.addViewedModels(models);
+    }
+}
+exports.toggleModels = toggleModels;
+/**
+ * Checks if all given models are displayed in given viewport.
+ * @public
+ */
+function areAllModelsVisible(models, viewport) {
+    return models.length !== 0 ? models.every((id) => viewport.viewsModel(id)) : false;
+}
+exports.areAllModelsVisible = areAllModelsVisible;
+//# sourceMappingURL=ModelsTreeVisibilityHandler.js.map