@itwin/tree-widget-react 1.2.1 → 2.0.0-dev.0

package/lib/esm/components/trees/models-tree/ModelsVisibilityHandler.js

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
 import { BeEvent } from "@itwin/core-bentley";
 import { QueryBinder, QueryRowFormat } from "@itwin/core-common";
 import { IModelApp, PerModelCategoryVisibility } from "@itwin/core-frontend";
@@ -61,20 +61,28 @@ export class ModelsVisibilityHandler {
         clearTimeout(this._pendingVisibilityChange);
     }
     /** Sets data provider that is used to get filtered tree hierarchy. */
-    setFilteredDataProvider(provider) { this._filteredDataProvider = provider; }
+    setFilteredDataProvider(provider) {
+        this._filteredDataProvider = provider;
+    }
     static getNodeType(item) {
-        if (!isPresentationTreeNodeItem(item))
+        if (!isPresentationTreeNodeItem(item)) {
             return ModelsTreeNodeType.Unknown;
-        if (NodeKey.isClassGroupingNodeKey(item.key))
+        }
+        if (NodeKey.isClassGroupingNodeKey(item.key)) {
             return ModelsTreeNodeType.Grouping;
-        if (!item.extendedData)
+        }
+        if (!item.extendedData) {
             return ModelsTreeNodeType.Unknown;
-        if (this.isSubjectNode(item))
+        }
+        if (this.isSubjectNode(item)) {
             return ModelsTreeNodeType.Subject;
-        if (this.isModelNode(item))
+        }
+        if (this.isModelNode(item)) {
             return ModelsTreeNodeType.Model;
-        if (this.isCategoryNode(item))
+        }
+        if (this.isCategoryNode(item)) {
             return ModelsTreeNodeType.Category;
+        }
         return ModelsTreeNodeType.Element;
     }
     static isSubjectNode(node) {
@@ -89,33 +97,40 @@ export class ModelsVisibilityHandler {
     /** Returns visibility status of the tree node. */
     getVisibilityStatus(node) {
         const nodeKey = isPresentationTreeNodeItem(node) ? node.key : undefined;
-        if (!nodeKey)
+        if (!nodeKey) {
             return { state: "hidden", isDisabled: true };
-        if (NodeKey.isClassGroupingNodeKey(nodeKey))
+        }
+        if (NodeKey.isClassGroupingNodeKey(nodeKey)) {
             return this.getElementGroupingNodeDisplayStatus(node.id, nodeKey);
-        if (!NodeKey.isInstancesNodeKey(nodeKey))
+        }
+        if (!NodeKey.isInstancesNodeKey(nodeKey)) {
             return { state: "hidden", isDisabled: true };
+        }
         if (ModelsVisibilityHandler.isSubjectNode(node)) {
             // note: subject nodes may be merged to represent multiple subject instances
             return this.getSubjectNodeVisibility(nodeKey.instanceKeys.map((key) => key.id), node);
         }
-        if (ModelsVisibilityHandler.isModelNode(node))
+        if (ModelsVisibilityHandler.isModelNode(node)) {
             return this.getModelDisplayStatus(nodeKey.instanceKeys[0].id);
-        if (ModelsVisibilityHandler.isCategoryNode(node))
+        }
+        if (ModelsVisibilityHandler.isCategoryNode(node)) {
             return this.getCategoryDisplayStatus(nodeKey.instanceKeys[0].id, this.getCategoryParentModelId(node));
+        }
         return this.getElementDisplayStatus(nodeKey.instanceKeys[0].id, this.getElementModelId(node), this.getElementCategoryId(node));
     }
     /** Changes visibility of the items represented by the tree node. */
     async changeVisibility(node, on) {
         const nodeKey = isPresentationTreeNodeItem(node) ? node.key : undefined;
-        if (!nodeKey)
+        if (!nodeKey) {
             return;
+        }
         if (NodeKey.isClassGroupingNodeKey(nodeKey)) {
             await this.changeElementGroupingNodeState(nodeKey, on);
             return;
         }
-        if (!NodeKey.isInstancesNodeKey(nodeKey))
+        if (!NodeKey.isInstancesNodeKey(nodeKey)) {
             return;
+        }
         if (ModelsVisibilityHandler.isSubjectNode(node)) {
             await this.changeSubjectNodeState(nodeKey.instanceKeys.map((key) => key.id), node, on);
         }
@@ -130,38 +145,45 @@ export class ModelsVisibilityHandler {
         }
     }
     async getSubjectNodeVisibility(ids, node) {
-        if (!this._props.viewport.view.isSpatialView())
+        if (!this._props.viewport.view.isSpatialView()) {
             return { isDisabled: true, state: "hidden", tooltip: createTooltip("disabled", "subject.nonSpatialView") };
-        if (this._filteredDataProvider)
+        }
+        if (this._filteredDataProvider) {
             return this.getFilteredSubjectDisplayStatus(this._filteredDataProvider, ids, node);
+        }
         return this.getSubjectDisplayStatus(ids);
     }
     async getSubjectDisplayStatus(ids) {
         const modelIds = await this.getSubjectModelIds(ids);
         const isDisplayed = modelIds.some((modelId) => this.getModelDisplayStatus(modelId).state === "visible");
-        if (isDisplayed)
+        if (isDisplayed) {
             return { state: "visible", tooltip: createTooltip("visible", "subject.atLeastOneModelVisible") };
+        }
         return { state: "hidden", tooltip: createTooltip("hidden", "subject.allModelsHidden") };
     }
     async getFilteredSubjectDisplayStatus(provider, ids, node) {
-        if (provider.nodeMatchesFilter(node))
+        if (provider.nodeMatchesFilter(node)) {
             return this.getSubjectDisplayStatus(ids);
+        }
         const children = await provider.getNodes(node);
         const childrenDisplayStatuses = await Promise.all(children.map(async (childNode) => this.getVisibilityStatus(childNode)));
-        if (childrenDisplayStatuses.some((status) => status.state === "visible"))
+        if (childrenDisplayStatuses.some((status) => status.state === "visible")) {
             return { state: "visible", tooltip: createTooltip("visible", "subject.atLeastOneModelVisible") };
+        }
         return { state: "hidden", tooltip: createTooltip("hidden", "subject.allModelsHidden") };
     }
     getModelDisplayStatus(id) {
-        if (!this._props.viewport.view.isSpatialView())
+        if (!this._props.viewport.view.isSpatialView()) {
             return { isDisabled: true, state: "hidden", tooltip: createTooltip("disabled", "model.nonSpatialView") };
+        }
         const isDisplayed = this._props.viewport.view.viewsModel(id);
         return { state: isDisplayed ? "visible" : "hidden", tooltip: createTooltip(isDisplayed ? "visible" : "hidden", undefined) };
     }
     getCategoryDisplayStatus(id, parentModelId) {
         if (parentModelId) {
-            if (this.getModelDisplayStatus(parentModelId).state === "hidden")
+            if (this.getModelDisplayStatus(parentModelId).state === "hidden") {
                 return { state: "hidden", isDisabled: true, tooltip: createTooltip("disabled", "category.modelNotDisplayed") };
+            }
             const override = this._props.viewport.perModelCategoryVisibility.getOverride(parentModelId, id);
             switch (override) {
                 case PerModelCategoryVisibility.Override.Show:
@@ -180,8 +202,9 @@ export class ModelsVisibilityHandler {
     }
     async getElementGroupingNodeDisplayStatus(_id, key) {
         const { modelId, categoryId, elementIds } = await this.getGroupedElementIds(key);
-        if (!modelId || !this._props.viewport.view.viewsModel(modelId))
+        if (!modelId || !this._props.viewport.view.viewsModel(modelId)) {
             return { isDisabled: true, state: "hidden", tooltip: createTooltip("disabled", "element.modelNotDisplayed") };
+        }
         if (this._props.viewport.alwaysDrawn !== undefined && this._props.viewport.alwaysDrawn.size > 0) {
             let atLeastOneElementForceDisplayed = false;
             for await (const elementId of elementIds.getElementIds()) {
@@ -190,11 +213,13 @@ export class ModelsVisibilityHandler {
                     break;
                 }
             }
-            if (atLeastOneElementForceDisplayed)
+            if (atLeastOneElementForceDisplayed) {
                 return { state: "visible", tooltip: createTooltip("visible", "element.displayedThroughAlwaysDrawnList") };
+            }
         }
-        if (this._props.viewport.alwaysDrawn !== undefined && this._props.viewport.alwaysDrawn.size !== 0 && this._props.viewport.isAlwaysDrawnExclusive)
+        if (this._props.viewport.alwaysDrawn !== undefined && this._props.viewport.alwaysDrawn.size !== 0 && this._props.viewport.isAlwaysDrawnExclusive) {
             return { state: "hidden", tooltip: createTooltip("hidden", "element.hiddenDueToOtherElementsExclusivelyAlwaysDrawn") };
+        }
         // istanbul ignore else
         if (this._props.viewport.neverDrawn !== undefined && this._props.viewport.neverDrawn.size > 0) {
             let allElementsForceHidden = true;
@@ -204,38 +229,48 @@ export class ModelsVisibilityHandler {
                     break;
                 }
             }
-            if (allElementsForceHidden)
+            if (allElementsForceHidden) {
                 return { state: "hidden", tooltip: createTooltip("visible", "element.hiddenThroughNeverDrawnList") };
+            }
         }
-        if (categoryId && this.getCategoryDisplayStatus(categoryId, modelId).state === "visible")
+        if (categoryId && this.getCategoryDisplayStatus(categoryId, modelId).state === "visible") {
             return { state: "visible", tooltip: createTooltip("visible", undefined) };
+        }
         return { state: "hidden", tooltip: createTooltip("hidden", "element.hiddenThroughCategory") };
     }
     getElementDisplayStatus(elementId, modelId, categoryId) {
-        if (!modelId || !this._props.viewport.view.viewsModel(modelId))
+        if (!modelId || !this._props.viewport.view.viewsModel(modelId)) {
             return { isDisabled: true, state: "hidden", tooltip: createTooltip("disabled", "element.modelNotDisplayed") };
-        if (this._props.viewport.neverDrawn !== undefined && this._props.viewport.neverDrawn.has(elementId))
+        }
+        if (this._props.viewport.neverDrawn !== undefined && this._props.viewport.neverDrawn.has(elementId)) {
             return { state: "hidden", tooltip: createTooltip("hidden", "element.hiddenThroughNeverDrawnList") };
+        }
         if (this._props.viewport.alwaysDrawn !== undefined) {
-            if (this._props.viewport.alwaysDrawn.has(elementId))
+            if (this._props.viewport.alwaysDrawn.has(elementId)) {
                 return { state: "visible", tooltip: createTooltip("visible", "element.displayedThroughAlwaysDrawnList") };
-            if (this._props.viewport.alwaysDrawn.size !== 0 && this._props.viewport.isAlwaysDrawnExclusive)
+            }
+            if (this._props.viewport.alwaysDrawn.size !== 0 && this._props.viewport.isAlwaysDrawnExclusive) {
                 return { state: "hidden", tooltip: createTooltip("hidden", "element.hiddenDueToOtherElementsExclusivelyAlwaysDrawn") };
+            }
         }
-        if (categoryId && this.getCategoryDisplayStatus(categoryId, modelId).state === "visible")
+        if (categoryId && this.getCategoryDisplayStatus(categoryId, modelId).state === "visible") {
             return { state: "visible", tooltip: createTooltip("visible", undefined) };
+        }
         return { state: "hidden", tooltip: createTooltip("hidden", "element.hiddenThroughCategory") };
     }
     async changeSubjectNodeState(ids, node, on) {
-        if (!this._props.viewport.view.isSpatialView())
+        if (!this._props.viewport.view.isSpatialView()) {
             return;
-        if (this._filteredDataProvider)
+        }
+        if (this._filteredDataProvider) {
             return this.changeFilteredSubjectState(this._filteredDataProvider, ids, node, on);
+        }
         return this.changeSubjectState(ids, on);
     }
     async changeFilteredSubjectState(provider, ids, node, on) {
-        if (provider.nodeMatchesFilter(node))
+        if (provider.nodeMatchesFilter(node)) {
             return this.changeSubjectState(ids, on);
+        }
         const children = await provider.getNodes(node);
         return Promise.all(children.map(async (childNode) => this.changeVisibility(childNode, on)));
     }
@@ -244,21 +279,27 @@ export class ModelsVisibilityHandler {
         return this.changeModelsVisibility(modelIds, on);
     }
     async changeModelState(id, on) {
-        if (!this._props.viewport.view.isSpatialView())
+        if (!this._props.viewport.view.isSpatialView()) {
             return;
+        }
         return this.changeModelsVisibility([id], on);
     }
     async changeModelsVisibility(ids, visible) {
-        if (visible)
+        if (visible) {
             return this._props.viewport.addViewedModels(ids);
-        else
+        }
+        else {
             this._props.viewport.changeModelDisplay(ids, false);
+        }
     }
     changeCategoryState(categoryId, parentModelId, on) {
         if (parentModelId) {
             const isDisplayedInSelector = this._props.viewport.view.viewsCategory(categoryId);
-            const ovr = (on === isDisplayedInSelector) ? PerModelCategoryVisibility.Override.None
-                : on ? PerModelCategoryVisibility.Override.Show : PerModelCategoryVisibility.Override.Hide;
+            const ovr = on === isDisplayedInSelector
+                ? PerModelCategoryVisibility.Override.None
+                : on
+                    ? PerModelCategoryVisibility.Override.Show
+                    : PerModelCategoryVisibility.Override.Hide;
             this._props.viewport.perModelCategoryVisibility.setOverride(parentModelId, categoryId, ovr);
             if (ovr === PerModelCategoryVisibility.Override.None && on) {
                 // we took off the override which means the category is displayed in selector, but
@@ -277,36 +318,41 @@ export class ModelsVisibilityHandler {
         const childIdsContainer = this.getAssemblyElementIds(id);
         async function* elementIds() {
             yield id;
-            for await (const childId of childIdsContainer.getElementIds())
+            for await (const childId of childIdsContainer.getElementIds()) {
                 yield childId;
+            }
         }
         await this.changeElementsState(modelId, categoryId, elementIds(), on);
     }
     async changeElementsState(modelId, categoryId, elementIds, on) {
-        const isDisplayedByDefault = modelId && this.getModelDisplayStatus(modelId).state === "visible"
-            && categoryId && this.getCategoryDisplayStatus(categoryId, modelId).state === "visible";
+        const isDisplayedByDefault = modelId &&
+            this.getModelDisplayStatus(modelId).state === "visible" &&
+            categoryId &&
+            this.getCategoryDisplayStatus(categoryId, modelId).state === "visible";
         const isHiddenDueToExclusiveAlwaysDrawnElements = this._props.viewport.isAlwaysDrawnExclusive && this._props.viewport.alwaysDrawn && 0 !== this._props.viewport.alwaysDrawn.size;
         const currNeverDrawn = new Set(this._props.viewport.neverDrawn ? this._props.viewport.neverDrawn : []);
-        const currAlwaysDrawn = new Set(this._props.viewport.alwaysDrawn ?
-            this._props.viewport.alwaysDrawn : /* istanbul ignore next */ []);
+        const currAlwaysDrawn = new Set(this._props.viewport.alwaysDrawn ? this._props.viewport.alwaysDrawn : /* istanbul ignore next */ []);
         for await (const elementId of elementIds) {
             if (on) {
                 currNeverDrawn.delete(elementId);
-                if (!isDisplayedByDefault || isHiddenDueToExclusiveAlwaysDrawnElements)
+                if (!isDisplayedByDefault || isHiddenDueToExclusiveAlwaysDrawnElements) {
                     currAlwaysDrawn.add(elementId);
+                }
             }
             else {
                 currAlwaysDrawn.delete(elementId);
-                if (isDisplayedByDefault && !isHiddenDueToExclusiveAlwaysDrawnElements)
+                if (isDisplayedByDefault && !isHiddenDueToExclusiveAlwaysDrawnElements) {
                     currNeverDrawn.add(elementId);
+                }
             }
         }
         this._props.viewport.setNeverDrawn(currNeverDrawn);
         this._props.viewport.setAlwaysDrawn(currAlwaysDrawn, this._props.viewport.isAlwaysDrawnExclusive);
     }
     onVisibilityChangeInternal() {
-        if (this._pendingVisibilityChange)
+        if (this._pendingVisibilityChange) {
             return;
+        }
         this._pendingVisibilityChange = setTimeout(() => {
             this.onVisibilityChange.raiseEvent();
             this._pendingVisibilityChange = undefined;
@@ -322,8 +368,7 @@ export class ModelsVisibilityHandler {
         return elementNode.extendedData ? elementNode.extendedData.categoryId : /* istanbul ignore next */ undefined;
     }
     async getSubjectModelIds(subjectIds) {
-        return (await Promise.all(subjectIds.map(async (id) => this._subjectModelIdsCache.getSubjectModelIds(id))))
-            .reduce((allModelIds, curr) => [...allModelIds, ...curr], []);
+        return (await Promise.all(subjectIds.map(async (id) => this._subjectModelIdsCache.getSubjectModelIds(id)))).reduce((allModelIds, curr) => [...allModelIds, ...curr], []);
     }
     // istanbul ignore next
     getAssemblyElementIds(assemblyId) {
@@ -368,19 +413,22 @@ export class SubjectModelIdsCache {
         const targetPartitionSubjects = new Map();
         for (const subject of await querySubjects()) {
             // istanbul ignore else
-            if (subject.parentId)
+            if (subject.parentId) {
                 pushToMap(this._subjectsHierarchy, subject.parentId, subject.id);
+            }
             // istanbul ignore if
-            if (subject.targetPartitionId)
+            if (subject.targetPartitionId) {
                 pushToMap(targetPartitionSubjects, subject.targetPartitionId, subject.id);
+            }
         }
         this._subjectModels = new Map();
         for (const model of await queryModels()) {
             // istanbul ignore next
             const subjectIds = targetPartitionSubjects.get(model.id) ?? [];
             // istanbul ignore else
-            if (!subjectIds.includes(model.parentId))
+            if (!subjectIds.includes(model.parentId)) {
                 subjectIds.push(model.parentId);
+            }
             subjectIds.forEach((subjectId) => {
                 pushToMap(this._subjectModels, subjectId, model.id);
             });
@@ -394,11 +442,13 @@ export class SubjectModelIdsCache {
     }
     appendSubjectModelsRecursively(modelIds, subjectId) {
         const subjectModelIds = this._subjectModels.get(subjectId);
-        if (subjectModelIds)
+        if (subjectModelIds) {
             modelIds.push(...subjectModelIds);
+        }
         const childSubjectIds = this._subjectsHierarchy.get(subjectId);
-        if (childSubjectIds)
+        if (childSubjectIds) {
             childSubjectIds.forEach((cs) => this.appendSubjectModelsRecursively(modelIds, cs));
+        }
     }
     async getSubjectModelIds(subjectId) {
         await this.initCache();
@@ -421,8 +471,9 @@ class ElementIdsCache {
     }
     getAssemblyElementIds(assemblyId) {
         const ids = this._assemblyElementIdsCache.get(assemblyId);
-        if (ids)
+        if (ids) {
             return ids;
+        }
         const container = createAssemblyElementIdsContainer(this._imodel, this._rulesetId, assemblyId);
         this._assemblyElementIdsCache.set(assemblyId, container);
         return container;
@@ -430,8 +481,9 @@ class ElementIdsCache {
     async getGroupedElementIds(groupingNodeKey) {
         const keyString = JSON.stringify(groupingNodeKey);
         const ids = this._groupedElementIdsCache.get(keyString);
-        if (ids)
+        if (ids) {
             return ids;
+        }
         const info = await createGroupedElementsInfo(this._imodel, this._rulesetId, groupingNodeKey);
         this._groupedElementIdsCache.set(keyString, info);
         return info;
@@ -457,8 +509,9 @@ function createAssemblyElementIdsContainer(imodel, rulesetId, assemblyId) {
 async function createGroupedElementsInfo(imodel, rulesetId, groupingNodeKey) {
     const groupedElementIdsContainer = new CachingElementIdsContainer(createInstanceIdsGenerator(imodel, rulesetId, "AssemblyElementsRequest", [groupingNodeKey]));
     const elementId = await groupedElementIdsContainer.getElementIds().next();
-    if (elementId.done)
+    if (elementId.done) {
         throw new Error("Invalid grouping node key");
+    }
     let modelId, categoryId;
     const query = `SELECT Model.Id AS modelId, Category.Id AS categoryId FROM bis.GeometricElement3d WHERE ECInstanceId = ? LIMIT 1`;
     const reader = imodel.createQueryReader(query, QueryBinder.from([elementId.value]), { rowFormat: QueryRowFormat.UseJsPropertyNames });
@@ -471,8 +524,9 @@ async function createGroupedElementsInfo(imodel, rulesetId, groupingNodeKey) {
 const createTooltip = (status, tooltipStringId) => {
     const statusStringId = `modelTree.status.${status}`;
     const statusString = TreeWidget.translate(statusStringId);
-    if (!tooltipStringId)
+    if (!tooltipStringId) {
         return statusString;
+    }
     tooltipStringId = `modelTree.tooltips.${tooltipStringId}`;
     const tooltipString = TreeWidget.translate(tooltipStringId);
     return `${statusString}: ${tooltipString}`;
@@ -503,10 +557,12 @@ export async function invertAllModels(models, viewport) {
     const notViewedModels = [];
     const viewedModels = [];
     models.forEach((modelId) => {
-        if (viewport.viewsModel(modelId))
+        if (viewport.viewsModel(modelId)) {
             viewedModels.push(modelId);
-        else
+        }
+        else {
             notViewedModels.push(modelId);
+        }
     });
     await viewport.addViewedModels(notViewedModels);
     viewport.changeModelDisplay(viewedModels, false);
@@ -517,12 +573,15 @@ export async function invertAllModels(models, viewport) {
  */
 export async function toggleModels(models, enable, viewport) {
     // istanbul ignore if
-    if (!models)
+    if (!models) {
         return;
-    if (enable)
+    }
+    if (enable) {
         viewport.changeModelDisplay(models, false);
-    else
+    }
+    else {
         await viewport.addViewedModels(models);
+    }
 }
 /**
  * Checks if all given models are displayed in given viewport.