@itwin/tree-widget-react 4.0.0-alpha.3 → 4.0.0-alpha.4

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

@@ -2,8 +2,8 @@
  * 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 { concat, concatAll, defer, distinct, EMPTY, filter, firstValueFrom, forkJoin, from, fromEventPattern, map, merge, mergeMap, of, reduce, shareReplay, startWith, Subject, take, takeUntil, tap, toArray, } from "rxjs";
+import { assert, Id64 } from "@itwin/core-bentley";
 import { PerModelCategoryVisibility } from "@itwin/core-frontend";
 import { HierarchyNode, HierarchyNodeKey } from "@itwin/presentation-hierarchies";
 import { toggleAllCategories } from "../../common/CategoriesVisibilityUtils.js";
@@ -66,6 +66,9 @@ class ModelsTreeVisibilityHandlerImpl {
         return toVoidPromise(changeObservable);
     }
     dispose() {
+        this[Symbol.dispose]();
+    }
+    [Symbol.dispose]() {
         this._eventListener.dispose();
         this._alwaysAndNeverDrawnElements.dispose();
         this._subscriptions.forEach((x) => x.unsubscribe());
@@ -154,7 +157,12 @@ class ModelsTreeVisibilityHandlerImpl {
                 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(mergeMap((categoryIds) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), this.getSubModeledElementsVisibilityStatus({
+                    ignoreTooltips: ignoreTooltip,
+                    haveSubModel: "yes",
+                    tooltips: { visible: undefined, hidden: "modelsTree.model.hiddenThroughModelSelector", partial: "modelsTree.model.someSubModelsVisible" },
+                    parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
+                }));
             }
             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;
@@ -182,7 +190,16 @@ class ModelsTreeVisibilityHandlerImpl {
     getCategoryDisplayStatus({ ignoreTooltip, ...props }) {
         const result = defer(() => {
             if (!this._props.viewport.view.viewsModel(props.modelId)) {
-                return of(createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughModel", ignoreTooltip)));
+                return from(this._idsCache.getCategoriesModeledElements(props.modelId, [props.categoryId])).pipe(this.getSubModeledElementsVisibilityStatus({
+                    ignoreTooltips: ignoreTooltip,
+                    parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
+                    tooltips: {
+                        visible: undefined,
+                        hidden: "modelsTree.category.hiddenThroughModel",
+                        partial: "modelsTree.category.someElementsOrSubModelsHidden",
+                    },
+                    haveSubModel: "yes",
+                }));
             }
             return this.getVisibilityFromAlwaysAndNeverDrawnElements({
                 queryProps: props,
@@ -194,7 +211,18 @@ class ModelsTreeVisibilityHandlerImpl {
                 },
                 defaultStatus: () => this.getDefaultCategoryVisibilityStatus(props),
                 ignoreTooltip,
-            });
+            }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
+                return from(this._idsCache.getCategoriesModeledElements(props.modelId, [props.categoryId])).pipe(this.getSubModeledElementsVisibilityStatus({
+                    tooltips: {
+                        visible: undefined,
+                        hidden: "modelsTree.category.allElementsAndSubModelsHidden",
+                        partial: "modelsTree.category.someElementsOrSubModelsHidden",
+                    },
+                    haveSubModel: "yes",
+                    parentNodeVisibilityStatus: visibilityStatusAlwaysAndNeverDraw,
+                    ignoreTooltips: ignoreTooltip,
+                }));
+            }));
         });
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.getCategoryDisplayStatus);
     }
@@ -203,7 +231,15 @@ class ModelsTreeVisibilityHandlerImpl {
             const info = this.getGroupingNodeInfo(node);
             const { modelId, categoryId, elementIds } = info;
             if (!this._props.viewport.view.viewsModel(modelId)) {
-                return of(createVisibilityStatus("hidden"));
+                return of([...elementIds]).pipe(this.getSubModeledElementsVisibilityStatus({
+                    tooltips: {
+                        visible: undefined,
+                        hidden: undefined,
+                        partial: "modelsTree.groupingNode.someElementsOrSubModelsHidden",
+                    },
+                    parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
+                    haveSubModel: "unknown",
+                }));
             }
             return this.getVisibilityFromAlwaysAndNeverDrawnElements({
                 elements: elementIds,
@@ -217,7 +253,17 @@ class ModelsTreeVisibilityHandlerImpl {
                     elementsInBothAlwaysAndNeverDrawn: "modelsTree.groupingNode.someElementsAreHidden",
                     noElementsInExclusiveAlwaysDrawnList: "modelsTree.groupingNode.allElementsHidden",
                 },
-            });
+            }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
+                return of([...elementIds]).pipe(this.getSubModeledElementsVisibilityStatus({
+                    tooltips: {
+                        visible: undefined,
+                        hidden: "modelsTree.groupingNode.allElementsAndSubModelsHidden",
+                        partial: "modelsTree.groupingNode.someElementsOrSubModelsHidden",
+                    },
+                    parentNodeVisibilityStatus: visibilityStatusAlwaysAndNeverDraw,
+                    haveSubModel: "unknown",
+                }));
+            }));
         });
         return createVisibilityHandlerResult(this, { node }, result, this._props.overrides?.getElementGroupingNodeDisplayStatus);
     }
@@ -236,19 +282,46 @@ class ModelsTreeVisibilityHandlerImpl {
         }
         return undefined;
     }
+    getElementVisibility(ignoreTooltip, viewsModel, overridenVisibility, categoryVisibility, subModelVisibilityStatus) {
+        if (subModelVisibilityStatus === undefined) {
+            if (!viewsModel) {
+                return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenThroughModel", ignoreTooltip));
+            }
+            if (overridenVisibility) {
+                return overridenVisibility;
+            }
+            return createVisibilityStatus(categoryVisibility.state, getTooltipOptions(categoryVisibility.state === "visible" ? undefined : "modelsTree.element.hiddenThroughCategory", ignoreTooltip));
+        }
+        if (subModelVisibilityStatus.state === "partial") {
+            return createVisibilityStatus("partial", getTooltipOptions("modelsTree.element.someElementsAreHidden", ignoreTooltip));
+        }
+        if (subModelVisibilityStatus.state === "visible") {
+            if (!viewsModel || overridenVisibility?.state === "hidden" || (categoryVisibility.state === "hidden" && !overridenVisibility)) {
+                return createVisibilityStatus("partial", getTooltipOptions("modelsTree.element.partialThroughSubModel", ignoreTooltip));
+            }
+            return createVisibilityStatus("visible", getTooltipOptions(undefined, ignoreTooltip));
+        }
+        if (!viewsModel) {
+            return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenThroughModel", ignoreTooltip));
+        }
+        if (overridenVisibility) {
+            if (overridenVisibility.state === "hidden") {
+                return overridenVisibility;
+            }
+            return createVisibilityStatus("partial", getTooltipOptions("modelsTree.element.partialThroughElement", ignoreTooltip));
+        }
+        if (categoryVisibility.state === "visible") {
+            return createVisibilityStatus("partial", getTooltipOptions("modelsTree.element.partialThroughCategory", ignoreTooltip));
+        }
+        return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenThroughCategory", ignoreTooltip));
+    }
     getElementDisplayStatus({ ignoreTooltip, ...props }) {
         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)));
+            const viewsModel = viewport.view.viewsModel(modelId);
+            const elementStatus = this.getElementOverriddenVisibility(elementId, ignoreTooltip);
+            return from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((hasSubModel) => (hasSubModel ? this.getModelVisibilityStatus({ modelId: elementId }) : of(undefined))), map((subModelVisibilityStatus) => this.getElementVisibility(ignoreTooltip, viewsModel, elementStatus, this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true }), subModelVisibilityStatus)));
         });
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.getElementDisplayStatus);
     }
@@ -329,20 +402,24 @@ class ModelsTreeVisibilityHandlerImpl {
         return createVisibilityHandlerResult(this, { ids, on }, result, this._props.overrides?.changeSubjectNodeState);
     }
     changeModelState(props) {
+        const { ids, on } = props;
+        if (Id64.sizeOf(ids) === 0) {
+            return EMPTY;
+        }
         const result = defer(() => {
             const viewport = this._props.viewport;
             if (!viewport.view.isSpatialView()) {
                 return EMPTY;
             }
-            const { ids, on } = props;
+            const idsObs = from(Id64.iterable(ids));
             if (!on) {
                 viewport.changeModelDisplay(ids, false);
-                return EMPTY;
+                return idsObs.pipe(mergeMap(async (modelId) => ({ modelId, categoryIds: await this._idsCache.getModelCategories(modelId) })), mergeMap(({ modelId, categoryIds }) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), mergeMap((modeledElementIds) => this.changeModelState({ ids: modeledElementIds, on })));
             }
             return concat(defer(() => {
                 viewport.perModelCategoryVisibility.clearOverrides(ids);
                 return from(viewport.addViewedModels(ids));
-            }), (typeof ids === "string" ? of(ids) : from(ids)).pipe(mergeMap((modelId) => {
+            }), idsObs.pipe(mergeMap((modelId) => {
                 return from(this._idsCache.getModelCategories(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.changeCategoryState({ categoryId, modelId, on: true })));
             })));
         });
@@ -386,25 +463,27 @@ class ModelsTreeVisibilityHandlerImpl {
             return concat(props.on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
                 this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, on);
                 return this.clearAlwaysAndNeverDrawnElements(props);
-            }));
+            }), from(this._idsCache.getCategoriesModeledElements(modelId, [categoryId])).pipe(mergeMap((modeledElementIds) => this.changeModelState({ ids: modeledElementIds, on }))));
         });
         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;
+    doChangeElementsState(props) {
+        return defer(() => {
+            const { modelId, categoryId, elementIds, on } = props;
             const viewport = this._props.viewport;
             return concat(on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
                 const categoryVisibility = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true });
                 const isDisplayedByDefault = categoryVisibility.state === "visible";
                 return this.queueElementsVisibilityChange(elementIds, on, isDisplayedByDefault);
-            }));
+            }), from(elementIds).pipe(mergeMap(async (elementId) => ({ elementId, isSubModel: await this._idsCache.hasSubModel(elementId) })), filter(({ isSubModel }) => isSubModel), map(({ elementId }) => elementId), toArray(), mergeMap((subModelIds) => this.changeModelState({ ids: subModelIds, on }))));
         });
+    }
+    /**
+     * Updates visibility of all grouping node's elements.
+     * @see `changeElementState`
+     */
+    changeElementGroupingNodeState(node, on) {
+        const result = this.doChangeElementsState({ ...this.getGroupingNodeInfo(node), on });
         return createVisibilityHandlerResult(this, { node, on }, result, this._props.overrides?.changeElementGroupingNodeState);
     }
     /**
@@ -412,15 +491,7 @@ class ModelsTreeVisibilityHandlerImpl {
      * @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);
-            }));
-        });
+        const result = this.doChangeElementsState(props);
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.changeElementsState);
     }
     queueElementsVisibilityChange(elementIds, on, visibleByDefault) {
@@ -564,6 +635,25 @@ class ModelsTreeVisibilityHandlerImpl {
         const elementIds = new Set(node.groupedInstanceKeys.map((key) => key.id));
         return { modelId, categoryId, elementIds };
     }
+    getSubModeledElementsVisibilityStatus({ parentNodeVisibilityStatus, haveSubModel, tooltips, ignoreTooltips, }) {
+        return (obs) => {
+            return obs.pipe(
+            // ensure we're only looking at elements that have a sub-model
+            mergeMap((modeledElementIds) => {
+                if (haveSubModel === "yes") {
+                    return of(modeledElementIds);
+                }
+                return from(modeledElementIds).pipe(mergeMap(async (elementId) => ({ elementId, hasSubModel: await this._idsCache.hasSubModel(elementId) })), filter(({ hasSubModel }) => hasSubModel), map(({ elementId }) => elementId), toArray());
+            }), 
+            // combine visibility status of sub-models with visibility status of parent node
+            mergeMap((modeledElementIds) => {
+                if (modeledElementIds.length === 0) {
+                    return of(parentNodeVisibilityStatus);
+                }
+                return from(modeledElementIds).pipe(mergeMap((modeledElementId) => this.getModelVisibilityStatus({ modelId: modeledElementId })), startWith(parentNodeVisibilityStatus), map((visibilityStatus) => visibilityStatus.state), getVisibilityStatusFromTreeNodeChildren(tooltips, ignoreTooltips));
+            }));
+        };
+    }
 }
 function getVisibilityFromTreeNodeChildren(obs) {
     return obs.pipe(reduceWhile((x) => x.allVisible || x.allHidden, (acc, val) => {