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

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

@@ -1,641 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * 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";
-import { KeySet, NodeKey } from "@itwin/presentation-common";
-import { isPresentationTreeNodeItem } from "@itwin/presentation-components";
-import { Presentation } from "@itwin/presentation-frontend";
-import { TreeWidget } from "../../../TreeWidget";
-import { toggleAllCategories } from "../CategoriesVisibilityUtils";
-import { CachingElementIdsContainer } from "./Utils";
-/**
- * Models tree node types.
- * @public
- */
-export var ModelsTreeNodeType;
-(function (ModelsTreeNodeType) {
-    ModelsTreeNodeType[ModelsTreeNodeType["Unknown"] = 0] = "Unknown";
-    ModelsTreeNodeType[ModelsTreeNodeType["Subject"] = 1] = "Subject";
-    ModelsTreeNodeType[ModelsTreeNodeType["Model"] = 2] = "Model";
-    ModelsTreeNodeType[ModelsTreeNodeType["Category"] = 3] = "Category";
-    ModelsTreeNodeType[ModelsTreeNodeType["Element"] = 4] = "Element";
-    ModelsTreeNodeType[ModelsTreeNodeType["Grouping"] = 5] = "Grouping";
-})(ModelsTreeNodeType || (ModelsTreeNodeType = {}));
-/**
- * Visibility handler used by [[ModelsTree]] to control visibility of the tree items.
- * @public
- */
-export class ModelsVisibilityHandler {
-    constructor(props) {
-        this._listeners = new Array();
-        this.onVisibilityChange = new BeEvent();
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        this.onViewChanged = (_vp) => {
-            this.onVisibilityChangeInternal();
-        };
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        this.onElementAlwaysDrawnChanged = () => {
-            this.onVisibilityChangeInternal();
-        };
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        this.onElementNeverDrawnChanged = () => {
-            this.onVisibilityChangeInternal();
-        };
-        this._props = props;
-        this._subjectModelIdsCache = props.subjectModelIdsCache ?? new SubjectModelIdsCache(this._props.viewport.iModel);
-        this._elementIdsCache = new ElementIdsCache(this._props.viewport.iModel);
-        this._listeners.push(this._props.viewport.onViewedCategoriesPerModelChanged.addListener(this.onViewChanged));
-        this._listeners.push(this._props.viewport.onViewedCategoriesChanged.addListener(this.onViewChanged));
-        this._listeners.push(this._props.viewport.onViewedModelsChanged.addListener(this.onViewChanged));
-        this._listeners.push(this._props.viewport.onAlwaysDrawnChanged.addListener(this.onElementAlwaysDrawnChanged));
-        this._listeners.push(this._props.viewport.onNeverDrawnChanged.addListener(this.onElementNeverDrawnChanged));
-        this._listeners.push(
-        // eslint-disable-next-line @itwin/no-internal
-        Presentation.presentation.onIModelHierarchyChanged.addListener(
-        /* istanbul ignore next */ () => {
-            this._elementIdsCache.clear();
-            this._subjectModelIdsCache.clear();
-        }));
-    }
-    dispose() {
-        this._listeners.forEach((remove) => remove());
-        clearTimeout(this._pendingVisibilityChange);
-    }
-    /** Sets data provider that is used to get filtered tree hierarchy. */
-    setFilteredDataProvider(provider) {
-        this._filteredDataProvider = provider;
-    }
-    static getNodeType(item) {
-        if (!isPresentationTreeNodeItem(item)) {
-            return ModelsTreeNodeType.Unknown;
-        }
-        if (NodeKey.isClassGroupingNodeKey(item.key)) {
-            return ModelsTreeNodeType.Grouping;
-        }
-        if (!item.extendedData) {
-            return ModelsTreeNodeType.Unknown;
-        }
-        if (this.isSubjectNode(item)) {
-            return ModelsTreeNodeType.Subject;
-        }
-        if (this.isModelNode(item)) {
-            return ModelsTreeNodeType.Model;
-        }
-        if (this.isCategoryNode(item)) {
-            return ModelsTreeNodeType.Category;
-        }
-        return ModelsTreeNodeType.Element;
-    }
-    static isSubjectNode(node) {
-        return node.extendedData && node.extendedData.isSubject;
-    }
-    static isModelNode(node) {
-        return node.extendedData && node.extendedData.isModel;
-    }
-    static isCategoryNode(node) {
-        return node.extendedData && node.extendedData.isCategory;
-    }
-    /** Returns visibility status of the tree node. */
-    getVisibilityStatus(node) {
-        const nodeKey = isPresentationTreeNodeItem(node) ? node.key : undefined;
-        if (!nodeKey) {
-            return { state: "hidden", isDisabled: true };
-        }
-        if (NodeKey.isClassGroupingNodeKey(nodeKey)) {
-            return this.getElementGroupingNodeDisplayStatus(node.id, 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)) {
-            return this.getModelDisplayStatus(nodeKey.instanceKeys[0].id);
-        }
-        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) {
-        if (!isPresentationTreeNodeItem(node)) {
-            return;
-        }
-        const nodeKey = node.key;
-        if (NodeKey.isClassGroupingNodeKey(nodeKey)) {
-            await this.changeElementGroupingNodeState(nodeKey, on);
-            return;
-        }
-        if (!NodeKey.isInstancesNodeKey(nodeKey)) {
-            return;
-        }
-        if (ModelsVisibilityHandler.isSubjectNode(node)) {
-            await this.changeSubjectNodeState(nodeKey.instanceKeys.map((key) => key.id), node, on);
-        }
-        else if (ModelsVisibilityHandler.isModelNode(node)) {
-            await this.changeModelState(nodeKey.instanceKeys[0].id, on);
-        }
-        else if (ModelsVisibilityHandler.isCategoryNode(node)) {
-            this.changeCategoryState(nodeKey.instanceKeys[0].id, this.getCategoryParentModelId(node), on);
-        }
-        else {
-            await this.changeElementState(nodeKey.instanceKeys[0].id, this.getElementModelId(node), this.getElementCategoryId(node), on, node.hasChildren);
-        }
-    }
-    async getSubjectNodeVisibility(ids, node) {
-        if (!this._props.viewport.view.isSpatialView()) {
-            return { isDisabled: true, state: "hidden", tooltip: createTooltip("disabled", "subject.nonSpatialView") };
-        }
-        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) {
-            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)) {
-            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")) {
-            return { state: "visible", tooltip: createTooltip("visible", "subject.atLeastOneModelVisible") };
-        }
-        return { state: "hidden", tooltip: createTooltip("hidden", "subject.allModelsHidden") };
-    }
-    getModelDisplayStatus(id) {
-        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") {
-                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:
-                    return { state: "visible", tooltip: createTooltip("visible", "category.displayedThroughPerModelOverride") };
-                case PerModelCategoryVisibility.Override.Hide:
-                    return { state: "hidden", tooltip: createTooltip("hidden", "category.hiddenThroughPerModelOverride") };
-            }
-        }
-        const isDisplayed = this._props.viewport.view.viewsCategory(id);
-        return {
-            state: isDisplayed ? "visible" : "hidden",
-            tooltip: isDisplayed
-                ? createTooltip("visible", "category.displayedThroughCategorySelector")
-                : createTooltip("hidden", "category.hiddenThroughCategorySelector"),
-        };
-    }
-    async getElementGroupingNodeDisplayStatus(_id, key) {
-        const { modelId, categoryId, elementIds } = await this.getGroupedElementIds(key);
-        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()) {
-                if (this._props.viewport.alwaysDrawn.has(elementId)) {
-                    atLeastOneElementForceDisplayed = true;
-                    break;
-                }
-            }
-            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) {
-            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;
-            for await (const elementId of elementIds.getElementIds()) {
-                if (!this._props.viewport.neverDrawn.has(elementId)) {
-                    allElementsForceHidden = false;
-                    break;
-                }
-            }
-            if (allElementsForceHidden) {
-                return { state: "hidden", tooltip: createTooltip("visible", "element.hiddenThroughNeverDrawnList") };
-            }
-        }
-        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)) {
-            return { isDisabled: true, state: "hidden", tooltip: createTooltip("disabled", "element.modelNotDisplayed") };
-        }
-        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)) {
-                return { state: "visible", tooltip: createTooltip("visible", "element.displayedThroughAlwaysDrawnList") };
-            }
-            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") {
-            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()) {
-            return;
-        }
-        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)) {
-            return this.changeSubjectState(ids, on);
-        }
-        const children = await provider.getNodes(node);
-        return Promise.all(children.map(async (childNode) => this.changeVisibility(childNode, on)));
-    }
-    async changeSubjectState(ids, on) {
-        const modelIds = await this.getSubjectModelIds(ids);
-        return this.changeModelsVisibility(modelIds, on);
-    }
-    async changeModelState(id, on) {
-        if (!this._props.viewport.view.isSpatialView()) {
-            return;
-        }
-        return this.changeModelsVisibility([id], on);
-    }
-    async changeModelsVisibility(ids, visible) {
-        if (visible) {
-            return this._props.viewport.addViewedModels(ids);
-        }
-        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;
-            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
-                // doesn't mean all its subcategories are displayed - this call ensures that
-                this._props.viewport.changeCategoryDisplay([categoryId], true, true);
-            }
-            return;
-        }
-        this._props.viewport.changeCategoryDisplay([categoryId], on, on ? true : false);
-    }
-    async changeElementGroupingNodeState(key, on) {
-        const { modelId, categoryId, elementIds } = await this.getGroupedElementIds(key);
-        await this.changeElementsState(modelId, categoryId, elementIds.getElementIds(), on);
-    }
-    async changeElementState(id, modelId, categoryId, on, hasChildren) {
-        const isDisplayedByDefault = this.isElementDisplayedByDefault(modelId, categoryId);
-        const isHiddenDueToExclusiveAlwaysDrawnElements = this.hasExclusiveAlwaysDrawnElements();
-        this.changeElementStateInternal(id, on, isDisplayedByDefault, isHiddenDueToExclusiveAlwaysDrawnElements);
-        if (!hasChildren) {
-            return;
-        }
-        const childIdsContainer = this.getAssemblyElementIds(id);
-        for await (const childId of childIdsContainer.getElementIds()) {
-            this.changeElementStateInternal(childId, on, isDisplayedByDefault, isHiddenDueToExclusiveAlwaysDrawnElements);
-        }
-    }
-    async changeElementsState(modelId, categoryId, elementIds, on) {
-        const isDisplayedByDefault = this.isElementDisplayedByDefault(modelId, categoryId);
-        const isHiddenDueToExclusiveAlwaysDrawnElements = this.hasExclusiveAlwaysDrawnElements();
-        for await (const elementId of elementIds) {
-            this.changeElementStateInternal(elementId, on, isDisplayedByDefault, isHiddenDueToExclusiveAlwaysDrawnElements);
-        }
-    }
-    changeElementStateInternal(elementId, on, isDisplayedByDefault, isHiddenDueToExclusiveAlwaysDrawnElements) {
-        let changedNeverDraw = false;
-        let changedAlwaysDrawn = false;
-        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 */ []);
-        if (on) {
-            changedNeverDraw = changedNeverDraw || currNeverDrawn.delete(elementId);
-            if ((!isDisplayedByDefault || isHiddenDueToExclusiveAlwaysDrawnElements) && !currAlwaysDrawn.has(elementId)) {
-                currAlwaysDrawn.add(elementId);
-                changedAlwaysDrawn = true;
-            }
-        }
-        else {
-            changedAlwaysDrawn = changedAlwaysDrawn || currAlwaysDrawn.delete(elementId);
-            if (isDisplayedByDefault && !isHiddenDueToExclusiveAlwaysDrawnElements && !currNeverDrawn.has(elementId)) {
-                currNeverDrawn.add(elementId);
-                changedNeverDraw = true;
-            }
-        }
-        changedNeverDraw && this._props.viewport.setNeverDrawn(currNeverDrawn);
-        changedAlwaysDrawn && this._props.viewport.setAlwaysDrawn(currAlwaysDrawn, this._props.viewport.isAlwaysDrawnExclusive);
-    }
-    isElementDisplayedByDefault(modelId, categoryId) {
-        return (!!modelId &&
-            this.getModelDisplayStatus(modelId).state === "visible" &&
-            !!categoryId &&
-            this.getCategoryDisplayStatus(categoryId, modelId).state === "visible");
-    }
-    hasExclusiveAlwaysDrawnElements() {
-        return this._props.viewport.isAlwaysDrawnExclusive && 0 !== this._props.viewport.alwaysDrawn?.size;
-    }
-    onVisibilityChangeInternal() {
-        if (this._pendingVisibilityChange) {
-            return;
-        }
-        this._pendingVisibilityChange = setTimeout(() => {
-            this.onVisibilityChange.raiseEvent();
-            this._pendingVisibilityChange = undefined;
-        }, 0);
-    }
-    getCategoryParentModelId(categoryNode) {
-        return categoryNode.extendedData ? categoryNode.extendedData.modelId : /* istanbul ignore next */ undefined;
-    }
-    getElementModelId(elementNode) {
-        return elementNode.extendedData ? elementNode.extendedData.modelId : /* istanbul ignore next */ undefined;
-    }
-    getElementCategoryId(elementNode) {
-        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], []);
-    }
-    // istanbul ignore next
-    getAssemblyElementIds(assemblyId) {
-        return this._elementIdsCache.getAssemblyElementIds(assemblyId);
-    }
-    // istanbul ignore next
-    async getGroupedElementIds(groupingNodeKey) {
-        return this._elementIdsCache.getGroupedElementIds(groupingNodeKey);
-    }
-}
-/** @internal */
-export class SubjectModelIdsCache {
-    constructor(imodel) {
-        this._imodel = imodel;
-    }
-    async initSubjectModels() {
-        const querySubjects = async () => {
-            const subjectsQuery = `
-        SELECT ECInstanceId id, Parent.Id parentId, json_extract(JsonProperties, '$.Subject.Model.TargetPartition') targetPartitionId
-        FROM bis.Subject
-      `;
-            return this._imodel.createQueryReader(subjectsQuery, undefined, { rowFormat: QueryRowFormat.UseJsPropertyNames }).toArray();
-        };
-        const queryModels = async () => {
-            const modelsQuery = `
-        SELECT p.ECInstanceId id, p.Parent.Id parentId
-        FROM bis.InformationPartitionElement p
-        INNER JOIN bis.GeometricModel3d m ON m.ModeledElement.Id = p.ECInstanceId
-        WHERE NOT m.IsPrivate
-      `;
-            return this._imodel.createQueryReader(modelsQuery, undefined, { rowFormat: QueryRowFormat.UseJsPropertyNames }).toArray();
-        };
-        function pushToMap(map, key, value) {
-            let list = map.get(key);
-            if (!list) {
-                list = [];
-                map.set(key, list);
-            }
-            list.push(value);
-        }
-        this._subjectsHierarchy = new Map();
-        const targetPartitionSubjects = new Map();
-        for (const subject of await querySubjects()) {
-            // istanbul ignore else
-            if (subject.parentId) {
-                pushToMap(this._subjectsHierarchy, subject.parentId, subject.id);
-            }
-            // istanbul ignore if
-            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)) {
-                subjectIds.push(model.parentId);
-            }
-            subjectIds.forEach((subjectId) => {
-                pushToMap(this._subjectModels, subjectId, model.id);
-            });
-        }
-    }
-    async initCache() {
-        if (!this._init) {
-            this._init = this.initSubjectModels().then(() => { });
-        }
-        return this._init;
-    }
-    appendSubjectModelsRecursively(modelIds, subjectId) {
-        const subjectModelIds = this._subjectModels.get(subjectId);
-        if (subjectModelIds) {
-            modelIds.push(...subjectModelIds);
-        }
-        const childSubjectIds = this._subjectsHierarchy.get(subjectId);
-        if (childSubjectIds) {
-            childSubjectIds.forEach((cs) => this.appendSubjectModelsRecursively(modelIds, cs));
-        }
-    }
-    // istanbul ignore next
-    clear() {
-        this._subjectsHierarchy?.clear();
-        this._subjectModels?.clear();
-        this._init = undefined;
-    }
-    async getSubjectModelIds(subjectId) {
-        await this.initCache();
-        const modelIds = new Array();
-        this.appendSubjectModelsRecursively(modelIds, subjectId);
-        return modelIds;
-    }
-}
-// istanbul ignore next
-class ElementIdsCache {
-    constructor(_imodel) {
-        this._imodel = _imodel;
-        this._assemblyElementIdsCache = new Map();
-        this._groupedElementIdsCache = new Map();
-    }
-    clear() {
-        this._assemblyElementIdsCache.clear();
-        this._groupedElementIdsCache.clear();
-    }
-    getAssemblyElementIds(assemblyId) {
-        const ids = this._assemblyElementIdsCache.get(assemblyId);
-        if (ids) {
-            return ids;
-        }
-        const container = createAssemblyElementIdsContainer(this._imodel, assemblyId);
-        this._assemblyElementIdsCache.set(assemblyId, container);
-        return container;
-    }
-    async getGroupedElementIds(groupingNodeKey) {
-        const keyString = JSON.stringify(groupingNodeKey);
-        const ids = this._groupedElementIdsCache.get(keyString);
-        if (ids) {
-            return ids;
-        }
-        const info = await createGroupedElementsInfo(this._imodel, groupingNodeKey);
-        this._groupedElementIdsCache.set(keyString, info);
-        return info;
-    }
-}
-// istanbul ignore next
-async function* createInstanceIdsGenerator(imodel, inputKeys) {
-    const res = await Presentation.presentation.getContentInstanceKeys({
-        imodel,
-        rulesetOrId: {
-            id: "ModelsTree/AssemblyElements",
-            rules: [
-                {
-                    ruleType: "Content",
-                    specifications: [
-                        {
-                            specType: "SelectedNodeInstances",
-                        },
-                        {
-                            specType: "ContentRelatedInstances",
-                            relationshipPaths: [
-                                {
-                                    relationship: {
-                                        schemaName: "BisCore",
-                                        className: "ElementOwnsChildElements",
-                                    },
-                                    direction: "Forward",
-                                    count: "*",
-                                },
-                            ],
-                        },
-                    ],
-                },
-            ],
-        },
-        keys: new KeySet(inputKeys),
-    });
-    for await (const key of res.items()) {
-        yield key.id;
-    }
-}
-// istanbul ignore next
-function createAssemblyElementIdsContainer(imodel, assemblyId) {
-    return new CachingElementIdsContainer(createInstanceIdsGenerator(imodel, [{ className: "BisCore:Element", id: assemblyId }]));
-}
-// istanbul ignore next
-async function createGroupedElementsInfo(imodel, groupingNodeKey) {
-    const groupedElementIdsContainer = new CachingElementIdsContainer(createInstanceIdsGenerator(imodel, [groupingNodeKey]));
-    const elementId = await groupedElementIdsContainer.getElementIds().next();
-    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 });
-    if (await reader.step()) {
-        modelId = reader.current.modelId;
-        categoryId = reader.current.categoryId;
-    }
-    return { modelId, categoryId, elementIds: groupedElementIdsContainer };
-}
-const createTooltip = (status, tooltipStringId) => {
-    const statusStringId = `modelTree.status.${status}`;
-    const statusString = TreeWidget.translate(statusStringId);
-    if (!tooltipStringId) {
-        return statusString;
-    }
-    tooltipStringId = `modelTree.tooltips.${tooltipStringId}`;
-    const tooltipString = TreeWidget.translate(tooltipStringId);
-    return `${statusString}: ${tooltipString}`;
-};
-/**
- * Enables display of all given models. Also enables display of all categories and clears always and
- * never drawn lists in the viewport.
- * @public
- */
-export async function showAllModels(models, viewport) {
-    await viewport.addViewedModels(models);
-    viewport.clearNeverDrawn();
-    viewport.clearAlwaysDrawn();
-    await toggleAllCategories(IModelApp.viewManager, viewport.iModel, true, viewport, false);
-}
-/**
- * Disables display of all given models.
- * @public
- */
-export async function hideAllModels(models, viewport) {
-    viewport.changeModelDisplay(models, false);
-}
-/**
- * Inverts display of all given models.
- * @public
- */
-export async function invertAllModels(models, viewport) {
-    const notViewedModels = [];
-    const viewedModels = [];
-    models.forEach((modelId) => {
-        if (viewport.viewsModel(modelId)) {
-            viewedModels.push(modelId);
-        }
-        else {
-            notViewedModels.push(modelId);
-        }
-    });
-    await viewport.addViewedModels(notViewedModels);
-    viewport.changeModelDisplay(viewedModels, false);
-}
-/**
- * Based on the value of `enable` argument, either enables or disables display of given models.
- * @public
- */
-export async function toggleModels(models, enable, viewport) {
-    // istanbul ignore if
-    if (!models) {
-        return;
-    }
-    if (enable) {
-        viewport.changeModelDisplay(models, false);
-    }
-    else {
-        await viewport.addViewedModels(models);
-    }
-}
-/**
- * Checks if all given models are displayed in given viewport.
- * @public
- */
-export function areAllModelsVisible(models, viewport) {
-    return models.length !== 0 ? models.every((id) => viewport.viewsModel(id)) : false;
-}
-//# sourceMappingURL=ModelsVisibilityHandler.js.map