@itwin/tree-widget-react 3.7.0 → 3.8.0

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

@@ -70,7 +70,7 @@ class ModelsTreeVisibilityHandlerImpl {
     }
     [Symbol.dispose]() {
         this._eventListener.dispose();
-        this._alwaysAndNeverDrawnElements.dispose();
+        this._alwaysAndNeverDrawnElements[Symbol.dispose]();
         this._subscriptions.forEach((x) => x.unsubscribe());
     }
     getVisibilityStatusObs(node) {
@@ -88,7 +88,7 @@ class ModelsTreeVisibilityHandlerImpl {
             return this.getSubjectNodeVisibilityStatus({ subjectIds: node.key.instanceKeys.map((key) => key.id) });
         }
         if (ModelsTreeNode.isModelNode(node)) {
-            return this.getModelVisibilityStatus({ modelId: node.key.instanceKeys[0].id });
+            return this.getModelVisibilityStatus({ modelIds: node.key.instanceKeys.map(({ id }) => id) });
         }
         const modelId = ModelsTreeNode.getModelId(node);
         if (!modelId) {
@@ -96,7 +96,7 @@ class ModelsTreeVisibilityHandlerImpl {
         }
         if (ModelsTreeNode.isCategoryNode(node)) {
             return this.getCategoryDisplayStatus({
-                categoryId: node.key.instanceKeys[0].id,
+                categoryIds: node.key.instanceKeys.map(({ id }) => id),
                 modelId,
             });
         }
@@ -117,12 +117,12 @@ class ModelsTreeVisibilityHandlerImpl {
                 observables.push(this.getSubjectNodeVisibilityStatus({ subjectIds: [...subjects], ignoreTooltip: true }));
             }
             if (models?.size) {
-                observables.push(from(models).pipe(mergeMap((modelId) => this.getModelVisibilityStatus({ modelId, ignoreTooltip: true }))));
+                observables.push(this.getModelVisibilityStatus({ modelIds: models, ignoreTooltip: true }));
             }
             if (categories?.size) {
                 observables.push(from(categories).pipe(mergeMap((key) => {
                     const { modelId, categoryId } = parseCategoryKey(key);
-                    return this.getCategoryDisplayStatus({ modelId, categoryId, ignoreTooltip: true });
+                    return this.getCategoryDisplayStatus({ modelId, categoryIds: categoryId, ignoreTooltip: true });
                 })));
             }
             if (elements?.size) {
@@ -132,17 +132,14 @@ class ModelsTreeVisibilityHandlerImpl {
                 })));
             }
             return merge(...observables);
-        }), map((x) => x.state), getVisibilityFromTreeNodeChildren, map((x) => {
-            assert(x !== "empty");
-            return createVisibilityStatus(x);
-        }));
+        }), mergeVisibilityStatuses());
     }
     getSubjectNodeVisibilityStatus({ subjectIds, ignoreTooltip }) {
         const result = defer(() => {
             if (!this._props.viewport.view.isSpatialView()) {
                 return of(createVisibilityStatus("disabled", getTooltipOptions("modelsTree.subject.nonSpatialView", ignoreTooltip)));
             }
-            return from(this._idsCache.getSubjectModelIds(subjectIds)).pipe(concatAll(), distinct(), mergeMap((modelId) => this.getModelVisibilityStatus({ modelId, ignoreTooltip: true })), map((x) => x.state), getVisibilityStatusFromTreeNodeChildren({
+            return from(this._idsCache.getSubjectModelIds(subjectIds)).pipe(mergeMap((modelIds) => this.getModelVisibilityStatus({ modelIds, ignoreTooltip: true })), mergeVisibilityStatuses({
                 visible: "modelsTree.subject.allModelsVisible",
                 hidden: "modelsTree.subject.allModelsHidden",
                 partial: "modelsTree.subject.someModelsHidden",
@@ -150,47 +147,68 @@ class ModelsTreeVisibilityHandlerImpl {
         });
         return createVisibilityHandlerResult(this, { ids: subjectIds }, result, this._props.overrides?.getSubjectNodeVisibility);
     }
-    getModelVisibilityStatus({ modelId, ignoreTooltip }) {
+    getModelVisibilityStatus({ modelIds, ignoreTooltip }) {
         const result = defer(() => {
             const viewport = this._props.viewport;
             if (!viewport.view.isSpatialView()) {
                 return of(createVisibilityStatus("disabled", getTooltipOptions("modelsTree.model.nonSpatialView", ignoreTooltip)));
             }
-            if (!viewport.view.viewsModel(modelId)) {
-                return 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(modelIds).pipe(distinct(), mergeMap((modelId) => {
+                if (!viewport.view.viewsModel(modelId)) {
+                    return from(this._idsCache.getModelCategories(modelId)).pipe(mergeMap((categoryIds) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), this.getSubModeledElementsVisibilityStatus({
+                        ignoreTooltips: ignoreTooltip,
+                        haveSubModel: "yes",
+                        tooltips: { visible: undefined, hidden: "modelsTree.model.hiddenThroughModelSelector", partial: "modelsTree.model.someSubModelsVisible" },
+                        parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
+                    }));
+                }
+                return from(this._idsCache.getModelCategories(modelId)).pipe(mergeMap((categoryIds) => categoryIds.length === 0 ? of(createVisibilityStatus("visible")) : this.getCategoryDisplayStatus({ modelId, categoryIds, ignoreTooltip: true })), mergeVisibilityStatuses({
+                    visible: "modelsTree.model.allCategoriesVisible",
+                    partial: "modelsTree.model.someCategoriesHidden",
+                    hidden: "modelsTree.model.allCategoriesHidden",
                 }));
-            }
-            return from(this._idsCache.getModelCategories(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.getCategoryDisplayStatus({ modelId, categoryId, ignoreTooltip: true })), map((x) => x.state), getVisibilityFromTreeNodeChildren, map((visibilityByCategories) => {
-                const state = visibilityByCategories === "empty" ? "visible" : visibilityByCategories;
-                return createVisibilityStatus(state, getTooltipOptions(state === "partial" ? "modelsTree.model.someCategoriesHidden" : `modelsTree.model.allCategories${state ? "Visible" : "Hidden"}`, ignoreTooltip));
-            }));
+            }), mergeVisibilityStatuses());
         });
-        return createVisibilityHandlerResult(this, { id: modelId }, result, this._props.overrides?.getModelDisplayStatus);
+        return createVisibilityHandlerResult(this, { ids: modelIds }, result, this._props.overrides?.getModelDisplayStatus);
     }
-    getDefaultCategoryVisibilityStatus({ modelId, categoryId, ignoreTooltip, }) {
+    getDefaultCategoryVisibilityStatus({ modelId, categoryIds, ignoreTooltip, }) {
         const viewport = this._props.viewport;
-        if (!viewport.view.viewsModel(modelId)) {
+        if (!viewport.view.viewsModel(modelId) || Id64.sizeOf(categoryIds) === 0) {
             return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughModel", ignoreTooltip));
         }
-        switch (this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId)) {
-            case PerModelCategoryVisibility.Override.Show:
-                return createVisibilityStatus("visible", getTooltipOptions("modelsTree.category.displayedThroughPerModelOverride", ignoreTooltip));
-            case PerModelCategoryVisibility.Override.Hide:
-                return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughPerModelOverride", ignoreTooltip));
+        let visibility = "unknown";
+        for (const categoryId of Id64.iterable(categoryIds)) {
+            const override = this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId);
+            if (override === PerModelCategoryVisibility.Override.Show) {
+                if (visibility === "hidden") {
+                    return createVisibilityStatus("partial");
+                }
+                visibility = "visible";
+                continue;
+            }
+            if (override === PerModelCategoryVisibility.Override.Hide) {
+                if (visibility === "visible") {
+                    return createVisibilityStatus("partial");
+                }
+                visibility = "hidden";
+                continue;
+            }
+            const isVisible = viewport.view.viewsCategory(categoryId);
+            if (isVisible && visibility === "hidden") {
+                return createVisibilityStatus("partial");
+            }
+            if (!isVisible && visibility === "visible") {
+                return createVisibilityStatus("partial");
+            }
+            visibility = isVisible ? "visible" : "hidden";
         }
-        const isVisible = viewport.view.viewsCategory(categoryId);
-        return isVisible
-            ? createVisibilityStatus("visible", getTooltipOptions("modelsTree.category.displayedThroughCategorySelector", ignoreTooltip))
-            : createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughCategorySelector", ignoreTooltip));
+        assert(visibility !== "unknown");
+        return createVisibilityStatus(visibility);
     }
     getCategoryDisplayStatus({ ignoreTooltip, ...props }) {
         const result = defer(() => {
             if (!this._props.viewport.view.viewsModel(props.modelId)) {
-                return from(this._idsCache.getCategoriesModeledElements(props.modelId, [props.categoryId])).pipe(this.getSubModeledElementsVisibilityStatus({
+                return from(this._idsCache.getCategoriesModeledElements(props.modelId, props.categoryIds)).pipe(this.getSubModeledElementsVisibilityStatus({
                     ignoreTooltips: ignoreTooltip,
                     parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
                     tooltips: {
@@ -202,17 +220,19 @@ class ModelsTreeVisibilityHandlerImpl {
                 }));
             }
             return this.getVisibilityFromAlwaysAndNeverDrawnElements({
-                queryProps: props,
+                categoryProps: { categoryIds: props.categoryIds, modelId: props.modelId },
                 tooltips: {
                     allElementsInAlwaysDrawnList: "modelsTree.category.allElementsVisible",
                     allElementsInNeverDrawnList: "modelsTree.category.allElementsHidden",
                     elementsInBothAlwaysAndNeverDrawn: "modelsTree.category.someElementsAreHidden",
                     noElementsInExclusiveAlwaysDrawnList: "modelsTree.category.allElementsHidden",
                 },
-                defaultStatus: () => this.getDefaultCategoryVisibilityStatus(props),
+                defaultStatus: (categoryId) => categoryId
+                    ? this.getDefaultCategoryVisibilityStatus({ modelId: props.modelId, categoryIds: categoryId })
+                    : this.getDefaultCategoryVisibilityStatus({ modelId: props.modelId, categoryIds: props.categoryIds }),
                 ignoreTooltip,
             }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
-                return from(this._idsCache.getCategoriesModeledElements(props.modelId, [props.categoryId])).pipe(this.getSubModeledElementsVisibilityStatus({
+                return from(this._idsCache.getCategoriesModeledElements(props.modelId, props.categoryIds)).pipe(this.getSubModeledElementsVisibilityStatus({
                     tooltips: {
                         visible: undefined,
                         hidden: "modelsTree.category.allElementsAndSubModelsHidden",
@@ -244,7 +264,7 @@ class ModelsTreeVisibilityHandlerImpl {
             return this.getVisibilityFromAlwaysAndNeverDrawnElements({
                 elements: elementIds,
                 defaultStatus: () => {
-                    const status = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true });
+                    const status = this.getDefaultCategoryVisibilityStatus({ categoryIds: categoryId, modelId, ignoreTooltip: true });
                     return createVisibilityStatus(status.state, getTooltipOptions(`modelsTree.groupingNode.${status.state}ThroughCategory`));
                 },
                 tooltips: {
@@ -321,7 +341,9 @@ class ModelsTreeVisibilityHandlerImpl {
             const { elementId, modelId, categoryId } = props;
             const viewsModel = viewport.view.viewsModel(modelId);
             const elementStatus = this.getElementOverriddenVisibility(elementId, ignoreTooltip);
-            return from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((hasSubModel) => (hasSubModel ? this.getModelVisibilityStatus({ modelId: elementId }) : of(undefined))), map((subModelVisibilityStatus) => this.getElementVisibility(ignoreTooltip, viewsModel, elementStatus, this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true }), subModelVisibilityStatus)));
+            return from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((hasSubModel) => (hasSubModel ? this.getModelVisibilityStatus({ modelIds: [elementId] }) : of(undefined))), map((subModelVisibilityStatus) => this.getElementVisibility(ignoreTooltip, viewsModel, elementStatus, 
+            // Single category will always return "visible" or "hidden"
+            this.getDefaultCategoryVisibilityStatus({ categoryIds: categoryId, modelId, ignoreTooltip: true }), subModelVisibilityStatus)));
         });
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.getElementDisplayStatus);
     }
@@ -340,7 +362,7 @@ class ModelsTreeVisibilityHandlerImpl {
             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 });
+            return this.changeModelState({ ids: node.key.instanceKeys.map(({ id }) => id), on });
         }
         const modelId = ModelsTreeNode.getModelId(node);
         if (!modelId) {
@@ -348,7 +370,7 @@ class ModelsTreeVisibilityHandlerImpl {
         }
         if (ModelsTreeNode.isCategoryNode(node)) {
             return this.changeCategoryState({
-                categoryId: node.key.instanceKeys[0].id,
+                categoryIds: node.key.instanceKeys.map(({ id }) => id),
                 modelId,
                 on,
             });
@@ -380,7 +402,7 @@ class ModelsTreeVisibilityHandlerImpl {
             if (categories?.size) {
                 observables.push(from(categories).pipe(mergeMap((key) => {
                     const { modelId, categoryId } = parseCategoryKey(key);
-                    return this.changeCategoryState({ modelId, categoryId, on });
+                    return this.changeCategoryState({ modelId, categoryIds: categoryId, on });
                 })));
             }
             if (elements?.size) {
@@ -420,7 +442,7 @@ class ModelsTreeVisibilityHandlerImpl {
                 viewport.perModelCategoryVisibility.clearOverrides(ids);
                 return from(viewport.addViewedModels(ids));
             }), idsObs.pipe(mergeMap((modelId) => {
-                return from(this._idsCache.getModelCategories(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.changeCategoryState({ categoryId, modelId, on: true })));
+                return from(this._idsCache.getModelCategories(modelId)).pipe(mergeMap((categoryIds) => this.changeCategoryState({ categoryIds, modelId, on: true })));
             })));
         });
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.changeModelState);
@@ -459,11 +481,13 @@ class ModelsTreeVisibilityHandlerImpl {
     changeCategoryState(props) {
         const result = defer(() => {
             const viewport = this._props.viewport;
-            const { modelId, categoryId, on } = props;
+            const { modelId, categoryIds, on } = props;
             return concat(props.on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
-                this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, on);
+                for (const categoryId of Id64.iterable(categoryIds)) {
+                    this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, on);
+                }
                 return this.clearAlwaysAndNeverDrawnElements(props);
-            }), from(this._idsCache.getCategoriesModeledElements(modelId, [categoryId])).pipe(mergeMap((modeledElementIds) => this.changeModelState({ ids: modeledElementIds, on }))));
+            }), from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds)).pipe(mergeMap((modeledElementIds) => this.changeModelState({ ids: modeledElementIds, on }))));
         });
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.changeCategoryState);
     }
@@ -472,7 +496,7 @@ class ModelsTreeVisibilityHandlerImpl {
             const { modelId, categoryId, elementIds, on } = props;
             const viewport = this._props.viewport;
             return concat(on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
-                const categoryVisibility = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true });
+                const categoryVisibility = this.getDefaultCategoryVisibilityStatus({ categoryIds: 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 }))));
@@ -594,25 +618,28 @@ class ModelsTreeVisibilityHandlerImpl {
                 ignoreTooltip,
             }));
         }
-        const { modelId, categoryId } = props.queryProps;
-        const totalCount = categoryId ? this._idsCache.getCategoryElementsCount(modelId, categoryId) : this._idsCache.getModelElementCount(modelId);
-        return forkJoin({
-            totalCount,
-            alwaysDrawn: this.getAlwaysDrawnElements(props.queryProps),
-            neverDrawn: this.getNeverDrawnElements(props.queryProps),
-        }).pipe(map((state) => {
-            return this.getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
-                ...props,
-                ...state,
-                ignoreTooltip,
-            });
-        }));
+        const { modelId, categoryIds } = props.categoryProps;
+        return from(Id64.iterable(categoryIds)).pipe(mergeMap((categoryId) => {
+            const totalCount = this._idsCache.getCategoryElementsCount(modelId, categoryId);
+            return forkJoin({
+                totalCount,
+                alwaysDrawn: this.getAlwaysDrawnElements({ categoryIds: categoryId, modelId }),
+                neverDrawn: this.getNeverDrawnElements({ categoryIds: categoryId, modelId }),
+            }).pipe(map((state) => {
+                return this.getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
+                    ...props,
+                    ...state,
+                    defaultStatus: () => props.defaultStatus(categoryId),
+                    ignoreTooltip,
+                });
+            }));
+        }), mergeVisibilityStatuses());
     }
     getAlwaysDrawnElements(props) {
-        return this._alwaysAndNeverDrawnElements.getElements({ ...props, setType: "always" });
+        return this._alwaysAndNeverDrawnElements.getElements({ modelId: props.modelId, categoryIds: props.categoryIds, setType: "always" });
     }
     getNeverDrawnElements(props) {
-        return this._alwaysAndNeverDrawnElements.getElements({ ...props, setType: "never" });
+        return this._alwaysAndNeverDrawnElements.getElements({ modelId: props.modelId, categoryIds: props.categoryIds, setType: "never" });
     }
     clearAlwaysAndNeverDrawnElements(props) {
         return forkJoin({
@@ -650,12 +677,12 @@ class ModelsTreeVisibilityHandlerImpl {
                 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));
+                return this.getModelVisibilityStatus({ modelIds: modeledElementIds }).pipe(startWith(parentNodeVisibilityStatus), mergeVisibilityStatuses(tooltips, ignoreTooltips));
             }));
         };
     }
 }
-function getVisibilityFromTreeNodeChildren(obs) {
+function mergeVisibilities(obs) {
     return obs.pipe(reduceWhile((x) => x.allVisible || x.allHidden, (acc, val) => {
         acc.allVisible &&= val === "visible";
         acc.allHidden &&= val === "hidden";
@@ -667,13 +694,13 @@ function getVisibilityFromTreeNodeChildren(obs) {
         return x.allVisible ? "visible" : x.allHidden ? "hidden" : "partial";
     }));
 }
-function getVisibilityStatusFromTreeNodeChildren(tooltipMap, ignoreTooltip) {
+function mergeVisibilityStatuses(tooltipMap, ignoreTooltip) {
     return (obs) => {
-        return getVisibilityFromTreeNodeChildren(obs).pipe(map((visibility) => {
+        return obs.pipe(map((visibilityStatus) => visibilityStatus.state), mergeVisibilities, map((visibility) => {
             if (visibility === "empty") {
                 visibility = "visible";
             }
-            return createVisibilityStatus(visibility, getTooltipOptions(tooltipMap[visibility], ignoreTooltip));
+            return createVisibilityStatus(visibility, getTooltipOptions(tooltipMap?.[visibility], ignoreTooltip));
         }));
     };
 }