@itwin/presentation-backend 4.0.0-dev.52 → 4.0.0-dev.54

package/lib/cjs/presentation-backend/SelectionScopesHelper.js

@@ -1,82 +1,82 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Core
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectionScopesHelper = void 0;
-const core_backend_1 = require("@itwin/core-backend");
-const core_bentley_1 = require("@itwin/core-bentley");
-const presentation_common_1 = require("@itwin/presentation-common");
-const Utils_1 = require("./Utils");
-/**
- * Contains helper methods for computing selection scopes. Will get removed
- * once rules-driven scopes are implemented.
- *
- * @internal
- */
-class SelectionScopesHelper {
-    // istanbul ignore next
-    constructor() { }
-    static getSelectionScopes() {
-        const createSelectionScope = (scopeId, label, description) => ({
-            id: scopeId,
-            label,
-            description,
-        });
-        return [
-            createSelectionScope("element", "Element", "Select the picked element"),
-            createSelectionScope("assembly", "Assembly", "Select parent of the picked element"),
-            createSelectionScope("top-assembly", "Top Assembly", "Select the topmost parent of the picked element"),
-            // WIP: temporarily comment-out "category" and "model" scopes since we can't hilite contents of them fast enough
-            // createSelectionScope("category", "Category", "Select all elements in the picked element's category"),
-            // createSelectionScope("model", "Model", "Select all elements in the picked element's model"),
-        ];
-    }
-    static getElementKey(iModel, elementId, ancestorLevel) {
-        let currId = elementId;
-        let parentId = iModel.elements.tryGetElementProps(currId)?.parent?.id;
-        while (parentId && ancestorLevel !== 0) {
-            currId = parentId;
-            parentId = iModel.elements.tryGetElementProps(currId)?.parent?.id;
-            --ancestorLevel;
-        }
-        return (0, Utils_1.getElementKey)(iModel, currId);
-    }
-    static computeElementSelection(iModel, elementIds, ancestorLevel) {
-        const parentKeys = new presentation_common_1.KeySet();
-        elementIds.forEach(skipTransients((id) => {
-            const key = this.getElementKey(iModel, id, ancestorLevel);
-            key && parentKeys.add(key);
-        }));
-        return parentKeys;
-    }
-    static computeCategorySelection(iModel, ids) {
-        const categoryKeys = new presentation_common_1.KeySet();
-        ids.forEach(skipTransients((id) => {
-            const el = iModel.elements.tryGetElement(id);
-            if (el instanceof core_backend_1.GeometricElement) {
-                const category = iModel.elements.tryGetElementProps(el.category);
-                if (category)
-                    categoryKeys.add({ className: category.classFullName, id: category.id });
-            }
-        }));
-        return categoryKeys;
-    }
-    static computeModelSelection(iModel, ids) {
-        const modelKeys = new presentation_common_1.KeySet();
-        ids.forEach(skipTransients((id) => {
-            const el = iModel.elements.tryGetElementProps(id);
-            const model = el ? iModel.models.tryGetModelProps(el.model) : undefined;
-            if (model)
-                modelKeys.add({ className: model.classFullName, id: model.id });
-        }));
-        return modelKeys;
-    }
-    static getRelatedFunctionalElementKey(imodel, graphicalElementId) {
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Core
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectionScopesHelper = void 0;
+const core_backend_1 = require("@itwin/core-backend");
+const core_bentley_1 = require("@itwin/core-bentley");
+const presentation_common_1 = require("@itwin/presentation-common");
+const Utils_1 = require("./Utils");
+/**
+ * Contains helper methods for computing selection scopes. Will get removed
+ * once rules-driven scopes are implemented.
+ *
+ * @internal
+ */
+class SelectionScopesHelper {
+    // istanbul ignore next
+    constructor() { }
+    static getSelectionScopes() {
+        const createSelectionScope = (scopeId, label, description) => ({
+            id: scopeId,
+            label,
+            description,
+        });
+        return [
+            createSelectionScope("element", "Element", "Select the picked element"),
+            createSelectionScope("assembly", "Assembly", "Select parent of the picked element"),
+            createSelectionScope("top-assembly", "Top Assembly", "Select the topmost parent of the picked element"),
+            // WIP: temporarily comment-out "category" and "model" scopes since we can't hilite contents of them fast enough
+            // createSelectionScope("category", "Category", "Select all elements in the picked element's category"),
+            // createSelectionScope("model", "Model", "Select all elements in the picked element's model"),
+        ];
+    }
+    static getElementKey(iModel, elementId, ancestorLevel) {
+        let currId = elementId;
+        let parentId = iModel.elements.tryGetElementProps(currId)?.parent?.id;
+        while (parentId && ancestorLevel !== 0) {
+            currId = parentId;
+            parentId = iModel.elements.tryGetElementProps(currId)?.parent?.id;
+            --ancestorLevel;
+        }
+        return (0, Utils_1.getElementKey)(iModel, currId);
+    }
+    static computeElementSelection(iModel, elementIds, ancestorLevel) {
+        const parentKeys = new presentation_common_1.KeySet();
+        elementIds.forEach(skipTransients((id) => {
+            const key = this.getElementKey(iModel, id, ancestorLevel);
+            key && parentKeys.add(key);
+        }));
+        return parentKeys;
+    }
+    static computeCategorySelection(iModel, ids) {
+        const categoryKeys = new presentation_common_1.KeySet();
+        ids.forEach(skipTransients((id) => {
+            const el = iModel.elements.tryGetElement(id);
+            if (el instanceof core_backend_1.GeometricElement) {
+                const category = iModel.elements.tryGetElementProps(el.category);
+                if (category)
+                    categoryKeys.add({ className: category.classFullName, id: category.id });
+            }
+        }));
+        return categoryKeys;
+    }
+    static computeModelSelection(iModel, ids) {
+        const modelKeys = new presentation_common_1.KeySet();
+        ids.forEach(skipTransients((id) => {
+            const el = iModel.elements.tryGetElementProps(id);
+            const model = el ? iModel.models.tryGetModelProps(el.model) : undefined;
+            if (model)
+                modelKeys.add({ className: model.classFullName, id: model.id });
+        }));
+        return modelKeys;
+    }
+    static getRelatedFunctionalElementKey(imodel, graphicalElementId) {
         const query = `
       SELECT funcSchemaDef.Name || '.' || funcClassDef.Name funcElClassName, fe.ECInstanceId funcElId
         FROM bis.Element e
@@ -86,29 +86,29 @@ class SelectionScopesHelper {
         INNER JOIN meta.ECClassDef funcClassDef ON funcClassDef.ECInstanceId = fe.ECClassId
         INNER JOIN meta.ECSchemaDef funcSchemaDef ON funcSchemaDef.ECInstanceId = funcClassDef.Schema.Id
        WHERE e.ECInstanceId = ?
-      `;
-        return imodel.withPreparedStatement(query, (stmt) => {
-            stmt.bindId(1, graphicalElementId);
-            // istanbul ignore else
-            if (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step()) {
-                const row = stmt.getRow();
-                if (row.funcElClassName && row.funcElId)
-                    return { className: row.funcElClassName.replace(".", ":"), id: row.funcElId };
-            }
-            return undefined;
-        });
-    }
-    static findFirstRelatedFunctionalElementKey(imodel, graphicalElementId) {
-        let currId = graphicalElementId;
-        while (currId) {
-            const relatedFunctionalKey = this.getRelatedFunctionalElementKey(imodel, currId);
-            if (relatedFunctionalKey)
-                return relatedFunctionalKey;
-            currId = imodel.elements.tryGetElementProps(currId)?.parent?.id;
-        }
-        return undefined;
-    }
-    static elementClassDerivesFrom(imodel, elementId, baseClassFullName) {
+      `;
+        return imodel.withPreparedStatement(query, (stmt) => {
+            stmt.bindId(1, graphicalElementId);
+            // istanbul ignore else
+            if (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step()) {
+                const row = stmt.getRow();
+                if (row.funcElClassName && row.funcElId)
+                    return { className: row.funcElClassName.replace(".", ":"), id: row.funcElId };
+            }
+            return undefined;
+        });
+    }
+    static findFirstRelatedFunctionalElementKey(imodel, graphicalElementId) {
+        let currId = graphicalElementId;
+        while (currId) {
+            const relatedFunctionalKey = this.getRelatedFunctionalElementKey(imodel, currId);
+            if (relatedFunctionalKey)
+                return relatedFunctionalKey;
+            currId = imodel.elements.tryGetElementProps(currId)?.parent?.id;
+        }
+        return undefined;
+    }
+    static elementClassDerivesFrom(imodel, elementId, baseClassFullName) {
         const query = `
       SELECT 1
       FROM bis.Element e
@@ -116,112 +116,112 @@ class SelectionScopesHelper {
       INNER JOIN meta.ECClassDef baseClass ON baseClass.ECInstanceId = baseClassRels.TargetECInstanceId
       INNER JOIN meta.ECSchemaDef baseSchema ON baseSchema.ECInstanceId = baseClass.Schema.Id
       WHERE e.ECInstanceId = ? AND (baseSchema.Name || ':' || baseClass.Name) = ?
-      `;
-        return imodel.withPreparedStatement(query, (stmt) => {
-            stmt.bindId(1, elementId);
-            stmt.bindString(2, baseClassFullName);
-            return (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step());
-        });
-    }
-    static computeFunctionalElementSelection(iModel, ids) {
-        const keys = new presentation_common_1.KeySet();
-        ids.forEach(skipTransients((id) => {
-            const is3d = this.elementClassDerivesFrom(iModel, id, core_backend_1.GeometricElement3d.classFullName);
-            if (!is3d) {
-                // if the input is not a 3d element, we try to find the first related functional element
-                const firstFunctionalKey = this.findFirstRelatedFunctionalElementKey(iModel, id);
-                if (firstFunctionalKey) {
-                    keys.add(firstFunctionalKey);
-                    return;
-                }
-            }
-            let keyToAdd;
-            if (is3d) {
-                // if we're computing scope for a 3d element, try to switch to its related functional element
-                keyToAdd = this.getRelatedFunctionalElementKey(iModel, id);
-            }
-            if (!keyToAdd)
-                keyToAdd = (0, Utils_1.getElementKey)(iModel, id);
-            keyToAdd && keys.add(keyToAdd);
-        }));
-        return keys;
-    }
-    static computeFunctionalAssemblySelection(iModel, ids) {
-        const keys = new presentation_common_1.KeySet();
-        ids.forEach(skipTransients((id) => {
-            let idToGetAssemblyFor = id;
-            const is3d = this.elementClassDerivesFrom(iModel, id, core_backend_1.GeometricElement3d.classFullName);
-            if (!is3d) {
-                // if the input is not a 3d element, we try to find the first related functional element
-                const firstFunctionalKey = this.findFirstRelatedFunctionalElementKey(iModel, id);
-                if (firstFunctionalKey)
-                    idToGetAssemblyFor = firstFunctionalKey.id;
-            }
-            // find the assembly of either the given element or the functional element
-            const assemblyKey = this.getElementKey(iModel, idToGetAssemblyFor, 1);
-            let keyToAdd = assemblyKey;
-            if (is3d && keyToAdd) {
-                // if we're computing scope for a 3d element, try to switch to its related functional element
-                const relatedFunctionalKey = this.getRelatedFunctionalElementKey(iModel, keyToAdd.id);
-                if (relatedFunctionalKey)
-                    keyToAdd = relatedFunctionalKey;
-            }
-            keyToAdd && keys.add(keyToAdd);
-        }));
-        return keys;
-    }
-    static computeFunctionalTopAssemblySelection(iModel, ids) {
-        const keys = new presentation_common_1.KeySet();
-        ids.forEach(skipTransients((id) => {
-            let idToGetAssemblyFor = id;
-            const is3d = this.elementClassDerivesFrom(iModel, id, core_backend_1.GeometricElement3d.classFullName);
-            if (!is3d) {
-                // if the input is not a 3d element, we try to find the first related functional element
-                const firstFunctionalKey = this.findFirstRelatedFunctionalElementKey(iModel, id);
-                if (firstFunctionalKey)
-                    idToGetAssemblyFor = firstFunctionalKey.id;
-            }
-            // find the top assembly of either the given element or the functional element
-            const topAssemblyKey = this.getElementKey(iModel, idToGetAssemblyFor, Number.MAX_SAFE_INTEGER);
-            let keyToAdd = topAssemblyKey;
-            if (is3d && keyToAdd) {
-                // if we're computing scope for a 3d element, try to switch to its related functional element
-                const relatedFunctionalKey = this.getRelatedFunctionalElementKey(iModel, keyToAdd.id);
-                if (relatedFunctionalKey)
-                    keyToAdd = relatedFunctionalKey;
-            }
-            keyToAdd && keys.add(keyToAdd);
-        }));
-        return keys;
-    }
-    static async computeSelection(requestOptions, elementIds, scopeId) {
-        if (!(0, presentation_common_1.isComputeSelectionRequestOptions)(requestOptions)) {
-            return this.computeSelection({
-                ...requestOptions,
-                elementIds: elementIds,
-                scope: { id: scopeId },
-            });
-        }
-        switch (requestOptions.scope.id) {
-            case "element": return this.computeElementSelection(requestOptions.imodel, requestOptions.elementIds, requestOptions.scope.ancestorLevel ?? 0);
-            case "assembly": return this.computeElementSelection(requestOptions.imodel, requestOptions.elementIds, 1);
-            case "top-assembly": return this.computeElementSelection(requestOptions.imodel, requestOptions.elementIds, Number.MAX_SAFE_INTEGER);
-            case "category": return this.computeCategorySelection(requestOptions.imodel, requestOptions.elementIds);
-            case "model": return this.computeModelSelection(requestOptions.imodel, requestOptions.elementIds);
-            case "functional":
-            case "functional-element":
-                return this.computeFunctionalElementSelection(requestOptions.imodel, requestOptions.elementIds);
-            case "functional-assembly": return this.computeFunctionalAssemblySelection(requestOptions.imodel, requestOptions.elementIds);
-            case "functional-top-assembly": return this.computeFunctionalTopAssemblySelection(requestOptions.imodel, requestOptions.elementIds);
-        }
-        throw new presentation_common_1.PresentationError(presentation_common_1.PresentationStatus.InvalidArgument, "scopeId");
-    }
-}
-exports.SelectionScopesHelper = SelectionScopesHelper;
-const skipTransients = (callback) => {
-    return (id) => {
-        if (!core_bentley_1.Id64.isTransient(id))
-            callback(id);
-    };
-};
+      `;
+        return imodel.withPreparedStatement(query, (stmt) => {
+            stmt.bindId(1, elementId);
+            stmt.bindString(2, baseClassFullName);
+            return (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step());
+        });
+    }
+    static computeFunctionalElementSelection(iModel, ids) {
+        const keys = new presentation_common_1.KeySet();
+        ids.forEach(skipTransients((id) => {
+            const is3d = this.elementClassDerivesFrom(iModel, id, core_backend_1.GeometricElement3d.classFullName);
+            if (!is3d) {
+                // if the input is not a 3d element, we try to find the first related functional element
+                const firstFunctionalKey = this.findFirstRelatedFunctionalElementKey(iModel, id);
+                if (firstFunctionalKey) {
+                    keys.add(firstFunctionalKey);
+                    return;
+                }
+            }
+            let keyToAdd;
+            if (is3d) {
+                // if we're computing scope for a 3d element, try to switch to its related functional element
+                keyToAdd = this.getRelatedFunctionalElementKey(iModel, id);
+            }
+            if (!keyToAdd)
+                keyToAdd = (0, Utils_1.getElementKey)(iModel, id);
+            keyToAdd && keys.add(keyToAdd);
+        }));
+        return keys;
+    }
+    static computeFunctionalAssemblySelection(iModel, ids) {
+        const keys = new presentation_common_1.KeySet();
+        ids.forEach(skipTransients((id) => {
+            let idToGetAssemblyFor = id;
+            const is3d = this.elementClassDerivesFrom(iModel, id, core_backend_1.GeometricElement3d.classFullName);
+            if (!is3d) {
+                // if the input is not a 3d element, we try to find the first related functional element
+                const firstFunctionalKey = this.findFirstRelatedFunctionalElementKey(iModel, id);
+                if (firstFunctionalKey)
+                    idToGetAssemblyFor = firstFunctionalKey.id;
+            }
+            // find the assembly of either the given element or the functional element
+            const assemblyKey = this.getElementKey(iModel, idToGetAssemblyFor, 1);
+            let keyToAdd = assemblyKey;
+            if (is3d && keyToAdd) {
+                // if we're computing scope for a 3d element, try to switch to its related functional element
+                const relatedFunctionalKey = this.getRelatedFunctionalElementKey(iModel, keyToAdd.id);
+                if (relatedFunctionalKey)
+                    keyToAdd = relatedFunctionalKey;
+            }
+            keyToAdd && keys.add(keyToAdd);
+        }));
+        return keys;
+    }
+    static computeFunctionalTopAssemblySelection(iModel, ids) {
+        const keys = new presentation_common_1.KeySet();
+        ids.forEach(skipTransients((id) => {
+            let idToGetAssemblyFor = id;
+            const is3d = this.elementClassDerivesFrom(iModel, id, core_backend_1.GeometricElement3d.classFullName);
+            if (!is3d) {
+                // if the input is not a 3d element, we try to find the first related functional element
+                const firstFunctionalKey = this.findFirstRelatedFunctionalElementKey(iModel, id);
+                if (firstFunctionalKey)
+                    idToGetAssemblyFor = firstFunctionalKey.id;
+            }
+            // find the top assembly of either the given element or the functional element
+            const topAssemblyKey = this.getElementKey(iModel, idToGetAssemblyFor, Number.MAX_SAFE_INTEGER);
+            let keyToAdd = topAssemblyKey;
+            if (is3d && keyToAdd) {
+                // if we're computing scope for a 3d element, try to switch to its related functional element
+                const relatedFunctionalKey = this.getRelatedFunctionalElementKey(iModel, keyToAdd.id);
+                if (relatedFunctionalKey)
+                    keyToAdd = relatedFunctionalKey;
+            }
+            keyToAdd && keys.add(keyToAdd);
+        }));
+        return keys;
+    }
+    static async computeSelection(requestOptions, elementIds, scopeId) {
+        if (!(0, presentation_common_1.isComputeSelectionRequestOptions)(requestOptions)) {
+            return this.computeSelection({
+                ...requestOptions,
+                elementIds: elementIds,
+                scope: { id: scopeId },
+            });
+        }
+        switch (requestOptions.scope.id) {
+            case "element": return this.computeElementSelection(requestOptions.imodel, requestOptions.elementIds, requestOptions.scope.ancestorLevel ?? 0);
+            case "assembly": return this.computeElementSelection(requestOptions.imodel, requestOptions.elementIds, 1);
+            case "top-assembly": return this.computeElementSelection(requestOptions.imodel, requestOptions.elementIds, Number.MAX_SAFE_INTEGER);
+            case "category": return this.computeCategorySelection(requestOptions.imodel, requestOptions.elementIds);
+            case "model": return this.computeModelSelection(requestOptions.imodel, requestOptions.elementIds);
+            case "functional":
+            case "functional-element":
+                return this.computeFunctionalElementSelection(requestOptions.imodel, requestOptions.elementIds);
+            case "functional-assembly": return this.computeFunctionalAssemblySelection(requestOptions.imodel, requestOptions.elementIds);
+            case "functional-top-assembly": return this.computeFunctionalTopAssemblySelection(requestOptions.imodel, requestOptions.elementIds);
+        }
+        throw new presentation_common_1.PresentationError(presentation_common_1.PresentationStatus.InvalidArgument, "scopeId");
+    }
+}
+exports.SelectionScopesHelper = SelectionScopesHelper;
+const skipTransients = (callback) => {
+    return (id) => {
+        if (!core_bentley_1.Id64.isTransient(id))
+            callback(id);
+    };
+};
 //# sourceMappingURL=SelectionScopesHelper.js.map