@itwin/editor-backend 3.0.0-dev.100

package/lib/cjs/EditBuiltInCommand.js

@@ -0,0 +1,622 @@
+"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 Editing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolidModelingCommand = exports.BasicManipulationCommand = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_geometry_1 = require("@itwin/core-geometry");
+const core_common_1 = require("@itwin/core-common");
+const editor_common_1 = require("@itwin/editor-common");
+const EditCommand_1 = require("./EditCommand");
+/** @alpha */
+class BasicManipulationCommand extends EditCommand_1.EditCommand {
+    constructor(iModel, _str) {
+        super(iModel);
+        this._str = _str;
+    }
+    async deleteElements(ids) {
+        for (const id of core_bentley_1.CompressedId64Set.iterable(ids))
+            this.iModel.elements.deleteElement(id);
+        return core_bentley_1.IModelStatus.Success;
+    }
+    async transformPlacement(ids, transProps) {
+        const transform = core_geometry_1.Transform.fromJSON(transProps);
+        for (const id of core_bentley_1.CompressedId64Set.iterable(ids)) {
+            const element = this.iModel.elements.getElement(id);
+            if (!element.placement.isValid)
+                continue; // Ignore assembly parents w/o geometry, etc...
+            element.placement.multiplyTransform(transform);
+            this.iModel.elements.updateElement(element);
+        }
+        return core_bentley_1.IModelStatus.Success;
+    }
+    async rotatePlacement(ids, matrixProps, aboutCenter) {
+        const matrix = core_geometry_1.Matrix3d.fromJSON(matrixProps);
+        for (const id of core_bentley_1.CompressedId64Set.iterable(ids)) {
+            const element = this.iModel.elements.getElement(id);
+            if (!element.placement.isValid)
+                continue; // Ignore assembly parents w/o geometry, etc...
+            const fixedPoint = aboutCenter ? element.placement.calculateRange().center : core_geometry_1.Point3d.createFrom(element.placement.origin);
+            const transform = core_geometry_1.Transform.createFixedPointAndMatrix(fixedPoint, matrix);
+            element.placement.multiplyTransform(transform);
+            this.iModel.elements.updateElement(element);
+        }
+        return core_bentley_1.IModelStatus.Success;
+    }
+    async insertGeometricElement(props, data) {
+        const newElem = this.iModel.elements.createElement(props);
+        const newId = this.iModel.elements.insertElement(newElem);
+        if (undefined === data)
+            return newId;
+        const updateProps = {
+            elementId: newId,
+            entryArray: data.entryArray,
+            isWorld: data.isWorld,
+            viewIndependent: data.viewIndependent,
+        };
+        const status = this.iModel.elementGeometryUpdate(updateProps);
+        if (core_bentley_1.DbResult.BE_SQLITE_OK !== status) {
+            this.iModel.elements.deleteElement(newId); // clean up element...
+            throw new core_common_1.IModelError(status, "Error updating element geometry");
+        }
+        return newId;
+    }
+    async insertGeometryPart(props, data) {
+        if (undefined === props.geom && undefined !== data) {
+            const builder = new core_common_1.GeometryStreamBuilder();
+            builder.appendGeometry(core_geometry_1.PointString3d.create(core_geometry_1.Point3d.createZero()));
+            props.geom = builder.geometryStream; // can't insert a DgnGeometryPart without geometry...
+        }
+        const newElem = this.iModel.elements.createElement(props);
+        const newId = this.iModel.elements.insertElement(newElem);
+        if (undefined === data)
+            return newId;
+        const updateProps = {
+            elementId: newId,
+            entryArray: data.entryArray,
+            is2dPart: data.is2dPart,
+        };
+        const status = this.iModel.elementGeometryUpdate(updateProps);
+        if (core_bentley_1.DbResult.BE_SQLITE_OK !== status) {
+            this.iModel.elements.deleteElement(newId); // clean up element...
+            throw new core_common_1.IModelError(status, "Error updating part geometry");
+        }
+        return newId;
+    }
+    async updateGeometricElement(propsOrId, data) {
+        let props;
+        if (typeof propsOrId === "string") {
+            if (undefined === data)
+                throw new core_common_1.IModelError(core_bentley_1.DbResult.BE_SQLITE_ERROR, "Flatbuffer data required for update by id");
+            props = this.iModel.elements.getElement(propsOrId);
+        }
+        else {
+            props = propsOrId;
+        }
+        if (undefined === props.id)
+            throw new core_common_1.IModelError(core_bentley_1.DbResult.BE_SQLITE_ERROR, "Element id required for update");
+        this.iModel.elements.updateElement(props);
+        if (undefined === data)
+            return;
+        const updateProps = {
+            elementId: props.id,
+            entryArray: data.entryArray,
+            isWorld: data.isWorld,
+            viewIndependent: data.viewIndependent,
+        };
+        const status = this.iModel.elementGeometryUpdate(updateProps);
+        if (core_bentley_1.DbResult.BE_SQLITE_OK !== status) {
+            throw new core_common_1.IModelError(status, "Error updating element geometry");
+        }
+    }
+    async requestElementGeometry(elementId, filter) {
+        let accepted;
+        const onGeometry = (info) => {
+            accepted = info;
+            if (undefined !== filter) {
+                let numDisplayable = 0;
+                for (const entry of info.entryArray) {
+                    if (!core_common_1.ElementGeometry.isDisplayableEntry(entry))
+                        continue;
+                    numDisplayable++;
+                    if (filter.maxDisplayable && numDisplayable > filter.maxDisplayable) {
+                        accepted = undefined;
+                        break;
+                    }
+                    if (filter.reject && filter.reject.some((opcode) => entry.opcode === opcode)) {
+                        accepted = undefined;
+                        break;
+                    }
+                    if (filter.accept && !filter.accept.some((opcode) => entry.opcode === opcode)) {
+                        accepted = undefined;
+                        break;
+                    }
+                    if (undefined === filter.geometry)
+                        continue;
+                    let entityType;
+                    if (filter.geometry.curves && !(filter.geometry.surfaces || filter.geometry.solids))
+                        entityType = core_common_1.ElementGeometry.isCurve(entry) ? core_common_1.BRepEntity.Type.Wire : undefined; // skip surface/solid opcodes...
+                    else
+                        entityType = core_common_1.ElementGeometry.getBRepEntityType(entry);
+                    switch (entityType) {
+                        case core_common_1.BRepEntity.Type.Wire:
+                            if (!filter.geometry.curves)
+                                accepted = undefined;
+                            break;
+                        case core_common_1.BRepEntity.Type.Sheet:
+                            if (!filter.geometry.surfaces)
+                                accepted = undefined;
+                            break;
+                        case core_common_1.BRepEntity.Type.Solid:
+                            if (!filter.geometry.solids)
+                                accepted = undefined;
+                            break;
+                        default:
+                            accepted = undefined;
+                            break;
+                    }
+                    if (undefined === accepted)
+                        break;
+                }
+            }
+        };
+        const requestProps = {
+            onGeometry,
+            elementId,
+        };
+        if (core_bentley_1.DbResult.BE_SQLITE_OK !== this.iModel.elementGeometryRequest(requestProps))
+            return undefined;
+        return accepted;
+    }
+    async updateProjectExtents(extents) {
+        const newExtents = new core_geometry_1.Range3d();
+        newExtents.setFromJSON(extents);
+        if (newExtents.isNull)
+            throw new core_common_1.IModelError(core_bentley_1.DbResult.BE_SQLITE_ERROR, "Invalid project extents");
+        this.iModel.updateProjectExtents(newExtents);
+        // Set source from calculated to user so connectors preserve the change.
+        const unitsProps = { name: "Units", namespace: "dgn_Db" };
+        const unitsStr = this.iModel.queryFilePropertyString(unitsProps);
+        if (undefined !== unitsStr) {
+            const unitsVal = JSON.parse(unitsStr);
+            const calculated = 1;
+            if (calculated !== unitsVal.extentsSource) {
+                unitsVal.extentsSource = calculated;
+                this.iModel.saveFileProperty(unitsProps, JSON.stringify(unitsVal));
+            }
+        }
+    }
+    async updateEcefLocation(ecefLocation) {
+        // Clear GCS that caller already determined was invalid...
+        this.iModel.deleteFileProperty({ name: "DgnGCS", namespace: "dgn_Db" });
+        const newEcefLocation = new core_common_1.EcefLocation(ecefLocation);
+        this.iModel.updateEcefLocation(newEcefLocation);
+    }
+}
+exports.BasicManipulationCommand = BasicManipulationCommand;
+BasicManipulationCommand.commandId = editor_common_1.editorBuiltInCmdIds.cmdBasicManipulation;
+var QuerySubEntity;
+(function (QuerySubEntity) {
+    /** Return whether the supplied face has a planar surface */
+    QuerySubEntity[QuerySubEntity["PlanarFace"] = 0] = "PlanarFace";
+    /** Return whether the angle between the normals of the supplied edge's faces never exceeds the internal smooth angle tolerance along the length of the edge */
+    QuerySubEntity[QuerySubEntity["SmoothEdge"] = 1] = "SmoothEdge";
+    /** Return whether the supplied sub-entity is a laminar edge of a sheet body, i.e. boundary of a single face */
+    QuerySubEntity[QuerySubEntity["LaminarEdge"] = 2] = "LaminarEdge";
+    /** Return whether the supplied sub-entity is a linear edge */
+    QuerySubEntity[QuerySubEntity["LinearEdge"] = 3] = "LinearEdge";
+    /** Return whether the angle between the normals of the supplied vertices's edges never exceeds the internal smooth angle tolerance along the length of the edge */
+    QuerySubEntity[QuerySubEntity["SmoothVertex"] = 4] = "SmoothVertex";
+})(QuerySubEntity || (QuerySubEntity = {}));
+var QueryBody;
+(function (QueryBody) {
+    /** Return whether the geometric primitive index is a disjoint body */
+    QueryBody[QueryBody["DisjointBody"] = 0] = "DisjointBody";
+    /** Return whether the geometric primitive index is a sheet body with a single planar face */
+    QueryBody[QueryBody["SingleFacePlanarSheet"] = 1] = "SingleFacePlanarSheet";
+    /** Return whether the geometric primitive index is a sheet or solid entity that has all planar faces */
+    QueryBody[QueryBody["OnlyPlanarFaces"] = 2] = "OnlyPlanarFaces";
+    /** Return whether the geometric primitive index is a body with any edge that is non-linear or any face that is non-planar */
+    QueryBody[QueryBody["CurvedFaceOrEdge"] = 3] = "CurvedFaceOrEdge";
+})(QueryBody || (QueryBody = {}));
+var OperationType;
+(function (OperationType) {
+    OperationType[OperationType["GeometrySummary"] = 0] = "GeometrySummary";
+    OperationType[OperationType["SubEntityGeometry"] = 1] = "SubEntityGeometry";
+    OperationType[OperationType["SubEntityParameterRange"] = 2] = "SubEntityParameterRange";
+    OperationType[OperationType["SubEntityEvaluate"] = 3] = "SubEntityEvaluate";
+    OperationType[OperationType["SubEntityQuery"] = 4] = "SubEntityQuery";
+    OperationType[OperationType["BodyQuery"] = 5] = "BodyQuery";
+    OperationType[OperationType["BodySubEntities"] = 6] = "BodySubEntities";
+    OperationType[OperationType["ConnectedSubEntity"] = 7] = "ConnectedSubEntity";
+    OperationType[OperationType["LocateSubEntity"] = 8] = "LocateSubEntity";
+    OperationType[OperationType["LocateFace"] = 9] = "LocateFace";
+    OperationType[OperationType["ClosestSubEntity"] = 10] = "ClosestSubEntity";
+    OperationType[OperationType["ClosestFace"] = 11] = "ClosestFace";
+    OperationType[OperationType["ClosestPoint"] = 12] = "ClosestPoint";
+    OperationType[OperationType["PointInside"] = 13] = "PointInside";
+    OperationType[OperationType["BooleanOp"] = 14] = "BooleanOp";
+    OperationType[OperationType["SewSheets"] = 15] = "SewSheets";
+    OperationType[OperationType["ThickenSheets"] = 16] = "ThickenSheets";
+    OperationType[OperationType["OffsetFaces"] = 17] = "OffsetFaces";
+    OperationType[OperationType["OffsetEdges"] = 18] = "OffsetEdges";
+    OperationType[OperationType["HollowFaces"] = 19] = "HollowFaces";
+    OperationType[OperationType["SweepFaces"] = 20] = "SweepFaces";
+    OperationType[OperationType["SpinFaces"] = 21] = "SpinFaces";
+    OperationType[OperationType["DeleteSubEntity"] = 22] = "DeleteSubEntity";
+    OperationType[OperationType["TransformSubEntity"] = 23] = "TransformSubEntity";
+    OperationType[OperationType["Blend"] = 24] = "Blend";
+    OperationType[OperationType["Chamfer"] = 25] = "Chamfer";
+    OperationType[OperationType["Cut"] = 26] = "Cut";
+    OperationType[OperationType["Emboss"] = 27] = "Emboss";
+    OperationType[OperationType["Imprint"] = 28] = "Imprint";
+    OperationType[OperationType["SweepBody"] = 29] = "SweepBody";
+    OperationType[OperationType["SpinBody"] = 30] = "SpinBody";
+    OperationType[OperationType["SweepPath"] = 31] = "SweepPath";
+    OperationType[OperationType["Loft"] = 32] = "Loft";
+})(OperationType || (OperationType = {}));
+/** @alpha */
+class SolidModelingCommand extends BasicManipulationCommand {
+    async updateElementGeometryCache(props) {
+        return this.iModel.nativeDb.updateElementGeometryCache(props);
+    }
+    async createElementGeometryCache(id, filter) {
+        var _a, _b, _c, _d, _e;
+        const result = await this.updateElementGeometryCache({ id });
+        if (core_bentley_1.BentleyStatus.SUCCESS !== result.status)
+            return false;
+        if (undefined === filter)
+            return true;
+        if (filter.minGeom && (undefined === result.numGeom || filter.minGeom > result.numGeom))
+            return false;
+        if (filter.maxGeom && (undefined === result.numGeom || filter.maxGeom < result.numGeom))
+            return false;
+        if (!filter.parts && ((_a = result.numPart) !== null && _a !== void 0 ? _a : 0 > 0))
+            return false;
+        if (!filter.curves && ((_b = result.numCurve) !== null && _b !== void 0 ? _b : 0 > 0))
+            return false;
+        if (!filter.surfaces && ((_c = result.numSurface) !== null && _c !== void 0 ? _c : 0 > 0))
+            return false;
+        if (!filter.solids && ((_d = result.numSolid) !== null && _d !== void 0 ? _d : 0 > 0))
+            return false;
+        if (!filter.other && ((_e = result.numOther) !== null && _e !== void 0 ? _e : 0 > 0))
+            return false;
+        return true;
+    }
+    async clearElementGeometryCache() {
+        await this.updateElementGeometryCache({});
+    }
+    async summarizeElementGeometryCache(id) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { onResult };
+        const props = { id, op: OperationType.GeometrySummary, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    requestSubEntityGeometry(id, subEntity) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { subEntity, onResult };
+        const props = { id, op: OperationType.SubEntityGeometry, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async getSubEntityGeometry(id, subEntity, opts) {
+        const geometryProps = this.requestSubEntityGeometry(id, subEntity);
+        if (undefined === (geometryProps === null || geometryProps === void 0 ? void 0 : geometryProps.geometry) || undefined === (geometryProps === null || geometryProps === void 0 ? void 0 : geometryProps.category))
+            return undefined;
+        const resultProps = {};
+        if (opts.wantGeometry)
+            resultProps.geometry = geometryProps.geometry;
+        if (opts.wantRange)
+            resultProps.range = ((geometryProps === null || geometryProps === void 0 ? void 0 : geometryProps.range) ? core_common_1.ElementGeometry.toElementAlignedBox3d(geometryProps === null || geometryProps === void 0 ? void 0 : geometryProps.range) : undefined);
+        if (opts.wantAppearance) {
+            const appearance = { category: geometryProps.category };
+            appearance.subCategory = geometryProps.subCategory;
+            appearance.material = geometryProps.material;
+            appearance.color = geometryProps.color;
+            appearance.transparency = geometryProps.transparency;
+            appearance.weight = geometryProps.weight;
+            resultProps.appearance = appearance;
+        }
+        if (!opts.wantGraphic)
+            return resultProps;
+        const requestId = opts.requestId ? opts.requestId : `SubEntity:${id}-${subEntity.id}`;
+        const toleranceLog10 = (opts.chordTolerance ? Math.floor(Math.log10(opts.chordTolerance)) : -2);
+        const requestProps = {
+            id: requestId,
+            modelId: this.iModel.iModelId,
+            toleranceLog10,
+            type: "3d",
+            placement: { origin: core_geometry_1.Point3d.createZero(), angles: core_geometry_1.YawPitchRollAngles.createDegrees(0, 0, 0) },
+            categoryId: geometryProps.category,
+            geometry: { format: "flatbuffer", data: [geometryProps.geometry] },
+        };
+        resultProps.graphic = await this.iModel.generateElementGraphics(requestProps);
+        return resultProps;
+    }
+    async getSubEntityParameterRange(id, subEntity) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { subEntity, onResult };
+        const props = { id, op: OperationType.SubEntityParameterRange, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async evaluateSubEntity(id, subEntity, uParam, vParam) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { subEntity, uParam, vParam, onResult };
+        const props = { id, op: OperationType.SubEntityEvaluate, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async subEntityQuery(id, subEntity, query) {
+        let accepted = false;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { subEntity, query, onResult };
+        const props = { id, op: OperationType.SubEntityQuery, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async isPlanarFace(id, subEntity) {
+        return this.subEntityQuery(id, subEntity, QuerySubEntity.PlanarFace);
+    }
+    async isSmoothEdge(id, subEntity) {
+        return this.subEntityQuery(id, subEntity, QuerySubEntity.SmoothEdge);
+    }
+    async isLaminarEdge(id, subEntity) {
+        return this.subEntityQuery(id, subEntity, QuerySubEntity.LaminarEdge);
+    }
+    async isLinearEdge(id, subEntity) {
+        return this.subEntityQuery(id, subEntity, QuerySubEntity.LinearEdge);
+    }
+    async isSmoothVertex(id, subEntity) {
+        return this.subEntityQuery(id, subEntity, QuerySubEntity.SmoothVertex);
+    }
+    async bodyQuery(id, index, query) {
+        let accepted = false;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { index, query, onResult };
+        const props = { id, op: OperationType.BodyQuery, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async isDisjointBody(id, index) {
+        return this.bodyQuery(id, index, QueryBody.DisjointBody);
+    }
+    async isSingleFacePlanarSheet(id, index) {
+        return this.bodyQuery(id, index, QueryBody.SingleFacePlanarSheet);
+    }
+    async hasOnlyPlanarFaces(id, index) {
+        return this.bodyQuery(id, index, QueryBody.OnlyPlanarFaces);
+    }
+    async hasCurvedFaceOrEdge(id, index) {
+        return this.bodyQuery(id, index, QueryBody.CurvedFaceOrEdge);
+    }
+    async getBodySubEntities(id, type, firstOnly) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { type, firstOnly, onResult };
+        const props = { id, op: OperationType.BodySubEntities, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async getConnectedSubEntities(id, subEntity, type, options) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { subEntity, type, options, onResult };
+        const props = { id, op: OperationType.ConnectedSubEntity, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async locateSubEntities(id, point, direction, options) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { point, direction, options, onResult };
+        const props = { id, op: OperationType.LocateSubEntity, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async locateFace(id, subEntity, point, direction) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { subEntity, point, direction, onResult };
+        const props = { id, op: OperationType.LocateFace, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async getClosestSubEntity(id, point) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { point, onResult };
+        const props = { id, op: OperationType.ClosestSubEntity, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async getClosestFace(id, point, direction) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { point, direction, onResult };
+        const props = { id, op: OperationType.ClosestFace, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async getClosestPoint(id, subEntity, point) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { subEntity, point, onResult };
+        const props = { id, op: OperationType.ClosestPoint, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async isPointInside(id, point) {
+        let accepted;
+        const onResult = (info) => {
+            accepted = info;
+        };
+        const params = { point, onResult };
+        const props = { id, op: OperationType.PointInside, params };
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        return accepted;
+    }
+    async getElementGeometryResults(id, info, opts) {
+        if (0 === info.entryArray.length || undefined === info.categoryId || undefined === info.bbox)
+            return undefined;
+        const resultProps = {};
+        if (opts.wantGeometry)
+            resultProps.geometry = info;
+        if (opts.wantRange)
+            resultProps.range = core_common_1.ElementGeometry.toElementAlignedBox3d(info.bbox);
+        if (opts.wantAppearance)
+            resultProps.categoryId = info.categoryId;
+        if (!(opts.wantGraphic || opts.writeChanges))
+            return resultProps;
+        let placement;
+        const sourceToWorld = (undefined === (info === null || info === void 0 ? void 0 : info.sourceToWorld) ? undefined : core_common_1.ElementGeometry.toTransform(info.sourceToWorld));
+        if (undefined === sourceToWorld) {
+            placement = { origin: core_geometry_1.Point3d.createZero(), angles: core_geometry_1.YawPitchRollAngles.createDegrees(0, 0, 0) };
+        }
+        else {
+            const origin = sourceToWorld.getOrigin();
+            const angles = new core_geometry_1.YawPitchRollAngles();
+            core_geometry_1.YawPitchRollAngles.createFromMatrix3d(sourceToWorld.matrix, angles);
+            placement = { origin, angles };
+        }
+        if (opts.writeChanges) {
+            if (opts.insertProps) {
+                opts.insertProps.placement = placement; // entryArray is local to this placement...
+                delete opts.insertProps.geom; // Ignore geometry if present...
+                resultProps.elementId = await this.insertGeometricElement(opts.insertProps, { entryArray: info.entryArray });
+            }
+            else {
+                const updateProps = this.iModel.elements.getElementProps({ id });
+                updateProps.category = info.categoryId; // allow category change...
+                updateProps.placement = placement; // entryArray is local to this placement...
+                await this.updateGeometricElement(updateProps, { entryArray: info.entryArray });
+                resultProps.elementId = id;
+            }
+        }
+        if (!opts.wantGraphic)
+            return resultProps;
+        const requestId = opts.requestId ? opts.requestId : `EGCacheOp:${id}`;
+        const toleranceLog10 = (opts.chordTolerance ? Math.floor(Math.log10(opts.chordTolerance)) : -2);
+        const requestProps = {
+            id: requestId,
+            modelId: this.iModel.iModelId,
+            toleranceLog10,
+            type: "3d",
+            placement,
+            categoryId: info.categoryId,
+            geometry: { format: "flatbuffer", data: info.entryArray },
+        };
+        resultProps.graphic = await this.iModel.generateElementGraphics(requestProps);
+        return resultProps;
+    }
+    async doElementGeometryOperation(props, opts) {
+        let accepted;
+        const onGeometry = (info) => {
+            accepted = info;
+        };
+        props.onGeometry = onGeometry;
+        this.iModel.nativeDb.elementGeometryCacheOperation(props);
+        if (undefined === accepted)
+            return undefined;
+        return this.getElementGeometryResults(props.id, accepted, opts);
+    }
+    async booleanOperation(id, params, opts) {
+        const props = { id, op: OperationType.BooleanOp, params };
+        const resultProps = await this.doElementGeometryOperation(props, opts);
+        // target insert = keep tools, target update = delete tools...
+        if (undefined !== resultProps && opts.writeChanges && undefined === opts.insertProps) {
+            for (const toolId of params.tools)
+                this.iModel.elements.deleteElement(toolId);
+        }
+        return resultProps;
+    }
+    async sewSheets(id, params, opts) {
+        const props = { id, op: OperationType.SewSheets, params };
+        const resultProps = await this.doElementGeometryOperation(props, opts);
+        // target insert = keep tools, target update = delete tools...
+        if (undefined !== resultProps && opts.writeChanges && undefined === opts.insertProps) {
+            for (const toolId of params.tools)
+                this.iModel.elements.deleteElement(toolId);
+        }
+        return resultProps;
+    }
+    async thickenSheets(id, params, opts) {
+        const props = { id, op: OperationType.ThickenSheets, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async offsetFaces(id, params, opts) {
+        const props = { id, op: OperationType.OffsetFaces, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async offsetEdges(id, params, opts) {
+        const props = { id, op: OperationType.OffsetEdges, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async hollowFaces(id, params, opts) {
+        const props = { id, op: OperationType.HollowFaces, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async sweepFaces(id, params, opts) {
+        const props = { id, op: OperationType.SweepFaces, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async spinFaces(id, params, opts) {
+        const props = { id, op: OperationType.SpinFaces, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async deleteSubEntities(id, params, opts) {
+        const props = { id, op: OperationType.DeleteSubEntity, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async transformSubEntities(id, params, opts) {
+        const props = { id, op: OperationType.TransformSubEntity, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async blendEdges(id, params, opts) {
+        const props = { id, op: OperationType.Blend, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+    async chamferEdges(id, params, opts) {
+        const props = { id, op: OperationType.Chamfer, params };
+        return this.doElementGeometryOperation(props, opts);
+    }
+}
+exports.SolidModelingCommand = SolidModelingCommand;
+SolidModelingCommand.commandId = editor_common_1.editorBuiltInCmdIds.cmdSolidModeling;
+//# sourceMappingURL=EditBuiltInCommand.js.map