@buerli.io/headless 0.4.1 → 0.5.0-beta.2

package/build/cjs/history.js

@@ -0,0 +1,1226 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-lines */
+const classcad_1 = require("@buerli.io/classcad");
+const core_1 = require("@buerli.io/core");
+const three_1 = require("three");
+const BufferGeometryUtils_ = __importStar(require("three/examples/jsm/utils/BufferGeometryUtils"));
+const selection_1 = require("./utils/selection");
+const featureAPI = classcad_1.ccAPI.feature;
+const sketcherAPI = classcad_1.ccAPI.sketcher;
+const base = classcad_1.ccUtils.base;
+let BufferGeometryUtils = BufferGeometryUtils_;
+if (BufferGeometryUtils.BufferGeometryUtils) {
+    BufferGeometryUtils = BufferGeometryUtils.BufferGeometryUtils;
+}
+/**
+ * Returns the data type of the given value
+ * @param value value to get the data type from
+ * @returns datatype of value
+ */
+const getDataType = (value) => {
+    switch (typeof value) {
+        case 'number':
+            return classcad_1.DataType.REAL;
+        case 'object':
+            return classcad_1.DataType.POINT;
+        case 'string':
+            return classcad_1.DataType.STRING;
+    }
+};
+/**
+ * Returns the cclass of the given dimension type
+ * @param type type of the dimension as string
+ * @returns cclass type of given type
+ */
+const getDimensionType = (type) => {
+    let cclass = classcad_1.CCClasses.CCLinearDimension;
+    switch (type) {
+        case 'LinearDimension':
+            cclass = classcad_1.CCClasses.CCLinearDimension;
+            break;
+    }
+    return cclass;
+};
+/**
+ * Transforms the transformation which is local to the ownerId into global
+ * transformation and returns it.
+ * @param ownerId node to get the global transformation from
+ * @param localTransformation transformation local to the owner, will be calculated into global transformation
+ * @returns the global transformation from local transformation to owner
+ */
+const getGlobalTransformation = (drawingId, ownerId, localTransformation) => {
+    const lT = localTransformation;
+    const coordSysOwner = classcad_1.ccUtils.assembly.getCoordSysFromNode(drawingId, ownerId);
+    if (coordSysOwner) {
+        const origin = [lT[0].x, lT[0].y, lT[0].z];
+        const xAxis = [lT[1].x, lT[1].y, lT[1].z];
+        const yAxis = [lT[2].x, lT[2].y, lT[2].z];
+        const zAxis = new three_1.Vector3().crossVectors(new three_1.Vector3(lT[1].x, lT[1].y, lT[1].z), new three_1.Vector3(lT[2].x, lT[2].y, lT[2].z));
+        const matrix = core_1.MathUtils.convertToMatrix4([origin, xAxis, yAxis, [zAxis.x, zAxis.y, zAxis.z]]);
+        const transformation = core_1.MathUtils.convertToMatrix4(coordSysOwner).clone().multiply(matrix);
+        const transformationCoords = core_1.MathUtils.convertToCoordinateSystem(transformation);
+        const tC = transformationCoords;
+        return [
+            { x: tC[0][0], y: tC[0][1], z: tC[0][2] },
+            { x: tC[1][0], y: tC[1][1], z: tC[1][2] },
+            { x: tC[2][0], y: tC[2][1], z: tC[2][2] },
+        ];
+    }
+    return undefined;
+};
+/**
+ * Helps to create the buffer geometry of the given object recursively.
+ * @param object object to create the buffergeometry from
+ * @param bufferGeomArray array to fill up with buffert geometries
+ */
+const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray) => {
+    let cDrawing = (0, core_1.getDrawing)(drawingId);
+    const tree = cDrawing.structure.tree;
+    if (object.link || object.solids) {
+        // Part
+        const solids = object.link ? tree[object.link].solids : object.solids;
+        if (solids != undefined) {
+            let geometries = [];
+            for (const solid of solids) {
+                let cachedSolid = cDrawing.geometry.cache[solid];
+                if (cachedSolid) {
+                    // if solid already cached, take it from cache
+                    geometries = [...geometries, ...cachedSolid.meshes.map(m => m.geometry)];
+                }
+                else {
+                    // else get visualisation from classcad
+                    await classcad_1.ccAPI.baseModeler.requestVisualisationOfEntities(drawingId, [solid]);
+                    cDrawing = (0, core_1.getDrawing)(drawingId); // get current drawing state after request
+                    cachedSolid = cDrawing.geometry.cache[solid];
+                    if (cachedSolid) {
+                        geometries = [...geometries, ...cachedSolid.meshes.map(m => m.geometry)];
+                    }
+                    else {
+                        console.warn(`There is no cached entry for ${solid}!`, cDrawing.geometry.cache);
+                    }
+                }
+            }
+            if (geometries.length > 0) {
+                const transformation = cDrawing.api.structure.calculateGlobalTransformation(object.id);
+                const bufferGeom = BufferGeometryUtils.mergeBufferGeometries(geometries);
+                bufferGeom.applyMatrix4(transformation);
+                bufferGeomArray.push(bufferGeom);
+            }
+        }
+    }
+    else if (object.children) {
+        // Assembly
+        for (const child of object.children) {
+            if (tree[child].class === classcad_1.CCClasses.CCProductReference || tree[child].class === classcad_1.CCClasses.CCProductReferenceET) {
+                await createRecursiveBufferGeometry(tree[child], drawingId, bufferGeomArray);
+            }
+        }
+    }
+};
+/**
+ * We traverse recursively over structure tree, starting with object and create three objects and meshes
+ * for the scene. Each part or assembly will be turned into groups and subgroups. Solids from parts will be turned
+ * into merged meshes, which are children of the group. Faces of a solid with different color
+ * or transparency will get its own mesh.
+ * @param object root object where we start building the three scene
+ * @param drawingId id of the drawing
+ * @param root the root of the scene
+ * @param options e.g. meshPerFace controls if each face gets a own mesh or if they will be combined/merged
+ */
+const createRecursiveScene = async (object, drawingId, root, options) => {
+    let cDrawing = (0, core_1.getDrawing)(drawingId);
+    const tree = cDrawing.structure.tree;
+    if (object.link || object.solids) {
+        // Part
+        const solids = object.link ? tree[object.link].solids : object.solids;
+        if (solids != undefined) {
+            let meshes = [];
+            const cachedSolids = [];
+            for (const solid of solids) {
+                let cachedSolid = cDrawing.geometry.cache[solid];
+                if (!cachedSolid) {
+                    // else get visualisation from classcad
+                    await classcad_1.ccAPI.baseModeler.requestVisualisationOfEntities(drawingId, [solid]);
+                    cDrawing = (0, core_1.getDrawing)(drawingId); // get current drawing state after request
+                    cachedSolid = cDrawing.geometry.cache[solid];
+                }
+                if (cachedSolid) {
+                    if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+                        meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
+                    }
+                    else {
+                        cachedSolids.push(cachedSolid);
+                    }
+                }
+            }
+            // If meshPerFace = true, we create for each face a separat mesh
+            if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+                if (meshes.length > 0) {
+                    const part = new three_1.Group();
+                    part.matrix = core_1.MathUtils.convertToMatrix4(object.coordinateSystem);
+                    part.matrixAutoUpdate = false;
+                    part.userData = { id: object.id }; // product reference id
+                    part.name = object.name; // product reference name
+                    for (const mesh of meshes) {
+                        part.add(new three_1.Mesh(mesh.geometry, new three_1.MeshStandardMaterial({ color: mesh.color, transparent: mesh.opacity < 1, opacity: mesh.opacity })));
+                    }
+                    root.add(part);
+                }
+            }
+            else {
+                if (cachedSolids.length > 0) {
+                    const part = new three_1.Group();
+                    part.matrix = core_1.MathUtils.convertToMatrix4(object.coordinateSystem);
+                    part.matrixAutoUpdate = false;
+                    part.userData = { id: object.id }; // product reference id
+                    part.name = object.name; // product reference name
+                    // A cached solid can have different colored faces, e.g. if a brep has been decorated.
+                    // In that case, we group the meshes with the same color/tranparency
+                    for (const cs of cachedSolids) {
+                        const colorMeshesMap = getDifferentColoredMeshesFromSolid(cs);
+                        Object.keys(colorMeshesMap).forEach(key => {
+                            const coloredMeshes = colorMeshesMap[key];
+                            const mesh = new three_1.Mesh();
+                            mesh.userData = { id: cs.container.ownerId }; // solid id
+                            mesh.name = tree[cs.container.ownerId].name; // solid name
+                            mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(coloredMeshes.map(m => m.geometry));
+                            mesh.material = new three_1.MeshStandardMaterial({
+                                color: coloredMeshes[0].color,
+                                transparent: coloredMeshes[0].opacity < 1,
+                                opacity: coloredMeshes[0].opacity,
+                            });
+                            part.add(mesh);
+                        });
+                    }
+                    root.add(part);
+                }
+            }
+        }
+    }
+    else if (object.children) {
+        // Assembly
+        const assembly = new three_1.Group();
+        assembly.matrix = core_1.MathUtils.convertToMatrix4(object.coordinateSystem);
+        assembly.matrixAutoUpdate = false;
+        assembly.userData = { id: object.id }; // assembly root or product reference id
+        assembly.name = object.name; // assembly root or product reference name
+        root.add(assembly);
+        for (const child of object.children) {
+            if (tree[child].class === classcad_1.CCClasses.CCProductReference || tree[child].class === classcad_1.CCClasses.CCProductReferenceET) {
+                await createRecursiveScene(tree[child], drawingId, assembly, options);
+            }
+        }
+    }
+};
+/**
+ * Get all meshes in a map, sorted by their color / transparency
+ * @param solid solid to look for the meshes
+ * @returns map (key = color/transparency as string, value = meshes array)
+ */
+const getDifferentColoredMeshesFromSolid = (solid) => {
+    const colorMeshesMap = {};
+    solid.meshes.forEach(mesh => {
+        const key = mesh.color.getHexString() + mesh.opacity.toString();
+        if (colorMeshesMap[key]) {
+            colorMeshesMap[key].push(mesh);
+        }
+        else {
+            colorMeshesMap[key] = [mesh];
+        }
+    });
+    return colorMeshesMap;
+};
+/**
+ * Helper function to log relevant points to find geometry to the console.
+ * This helps the user to copy the points directly from console to parameter of
+ * findOrSelect() method.
+ * @param points Array of points array to log to the console
+ */
+const logPoints = (points) => {
+    let log = 'Relevant points of selected gometry = [[';
+    if (points && points.length > 0) {
+        for (let i = 0; i < points.length; i++) {
+            for (let j = 0; j < points[i].length; j++) {
+                const x = Math.round(points[i][j].x * 1000) / 1000;
+                const y = Math.round(points[i][j].y * 1000) / 1000;
+                const z = Math.round(points[i][j].z * 1000) / 1000;
+                log += '{ x: ' + x + ', y: ' + y + ', z: ' + z + '}';
+                log += points[i].length - 1 === j ? '' : ',';
+            }
+            log += points.length - 1 === i ? ']]' : '],[';
+        }
+        console.info(log);
+    }
+};
+class CAD {
+    constructor() {
+        this.drawingId = null;
+        this.queue = Promise.resolve(0);
+        this.queue = Promise.resolve(0);
+    }
+    resolve(callback, ...args) {
+        return (this.queue = this.queue
+            .then(() => Promise.all(args).then(callback))
+            .catch(e => {
+            // catch is necessary to avoid error promises in the queue
+        }));
+    }
+    init(callback) {
+        const promise = new Promise(async (resolve, reject) => {
+            const drawingId = await classcad_1.ccAPI.base.createCCDrawing();
+            if (!drawingId)
+                throw new Error('Drawing could not be created');
+            this.drawingId = drawingId;
+            const publicApi = {
+                addNode: (productId, ownerId, transformation, name) => {
+                    return this.resolve(async ([rProductId, rOwnerId]) => {
+                        const globalTransformation = getGlobalTransformation(drawingId, rOwnerId, transformation) || transformation;
+                        return classcad_1.ccAPI.assemblyBuilder.addNode(drawingId, rProductId, rOwnerId, globalTransformation, name);
+                    }, productId, ownerId);
+                },
+                addNodes: async (...nodes) => {
+                    var e_1, _a;
+                    const nodesToAdd = [];
+                    try {
+                        for (var nodes_1 = __asyncValues(nodes), nodes_1_1; nodes_1_1 = await nodes_1.next(), !nodes_1_1.done;) {
+                            const node = nodes_1_1.value;
+                            const [rProductId, rOwnerId] = await new Promise(res => this.resolve(id => res(id), node.productId, node.ownerId));
+                            const nodeParam = {
+                                referenceId: rProductId,
+                                ownerId: rOwnerId,
+                                transformation: getGlobalTransformation(drawingId, rOwnerId, node.transformation) || node.transformation,
+                                name: node.name,
+                            };
+                            nodesToAdd.push(nodeParam);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) await _a.call(nodes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    return classcad_1.ccAPI.assemblyBuilder.addNodes(drawingId, nodesToAdd);
+                },
+                addDimension: (dim) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const dimensionType = getDimensionType(dim.dimParam.dimType);
+                        const dimParam = {
+                            productId: rProductId,
+                            param: {
+                                type: dimensionType,
+                                name: dim.dimParam.dimName,
+                                label: dim.dimParam.dimLabel,
+                                value: dim.dimParam.dimValue,
+                                startPos: dim.dimParam.dimStartPos,
+                                endPos: dim.dimParam.dimEndPos,
+                                textPos: dim.dimParam.dimTextPos,
+                                textAngle: dim.dimParam.dimTextAngle,
+                                orientation: dim.dimParam.dimOrientation,
+                                color: dim.dimParam.dimColor,
+                                layer: dim.dimParam.dimLayer,
+                            },
+                            dxfView: dim.dxfView,
+                        };
+                        return classcad_1.ccAPI.drawing2D.addDimension(drawingId, dimParam);
+                    }, dim.productId);
+                },
+                addDimensions: async (...dimensions) => {
+                    var e_2, _a;
+                    const dimParamsToAdd = [];
+                    try {
+                        for (var dimensions_1 = __asyncValues(dimensions), dimensions_1_1; dimensions_1_1 = await dimensions_1.next(), !dimensions_1_1.done;) {
+                            const dim = dimensions_1_1.value;
+                            const [rProductId] = await new Promise(res => this.resolve(id => res(id), dim.productId));
+                            const dimensionType = getDimensionType(dim.dimParam.dimType);
+                            const dimParam = {
+                                productId: rProductId,
+                                param: {
+                                    type: dimensionType,
+                                    name: dim.dimParam.dimName,
+                                    label: dim.dimParam.dimLabel,
+                                    value: dim.dimParam.dimValue,
+                                    startPos: dim.dimParam.dimStartPos,
+                                    endPos: dim.dimParam.dimEndPos,
+                                    textPos: dim.dimParam.dimTextPos,
+                                    textAngle: dim.dimParam.dimTextAngle,
+                                    orientation: dim.dimParam.dimOrientation,
+                                    color: dim.dimParam.dimColor,
+                                    layer: dim.dimParam.dimLayer,
+                                },
+                                dxfView: dim.dxfView,
+                            };
+                            dimParamsToAdd.push(dimParam);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (dimensions_1_1 && !dimensions_1_1.done && (_a = dimensions_1.return)) await _a.call(dimensions_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    return classcad_1.ccAPI.drawing2D.addDimensions(drawingId, dimParamsToAdd);
+                },
+                create2DViews: (productId, viewTypes, viewOptions) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const viewIds = await classcad_1.ccAPI.drawing2D.create2DViews(drawingId, rProductId, viewTypes, viewOptions);
+                        if (viewIds !== null) {
+                            await classcad_1.ccAPI.drawing2D.centerAllViews(drawingId, rProductId, viewTypes);
+                            return viewIds;
+                        }
+                        return null;
+                    }, productId);
+                },
+                getBoundaryBoxFromViews: (productId, viewTypes) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const bbs = await classcad_1.ccAPI.drawing2D.getBoundaryBoxFromViews(drawingId, rProductId, viewTypes);
+                        return bbs;
+                    }, productId);
+                },
+                place2DViews: (productId, viewPositions) => {
+                    return this.resolve(async ([rProductId]) => {
+                        return classcad_1.ccAPI.drawing2D.place2DViews(drawingId, rProductId, viewPositions);
+                    }, productId);
+                },
+                exportDXF: (productId, dxfTemplateFilename) => {
+                    return this.resolve(async ([rProductId]) => {
+                        return classcad_1.ccAPI.drawing2D.exportDXF(drawingId, rProductId, dxfTemplateFilename);
+                    }, productId);
+                },
+                exportSVG: (productId, modus, renderSize, dxfTemplateFilename) => {
+                    return this.resolve(async ([rProductId]) => {
+                        modus = modus ? modus : classcad_1.SVGModusType.FIT_WHOLE_DRAWING;
+                        const renderSizeParam = (renderSize === null || renderSize === void 0 ? void 0 : renderSize.x) && (renderSize === null || renderSize === void 0 ? void 0 : renderSize.y) ? [renderSize.x, renderSize.y] : undefined;
+                        return classcad_1.ccAPI.drawing2D.exportSVG(drawingId, rProductId, modus, renderSizeParam, dxfTemplateFilename);
+                    }, productId);
+                },
+                removeDimensions: (dimensionIds) => {
+                    return this.resolve(async ([...rDimensionIds]) => {
+                        return classcad_1.ccAPI.drawing2D.removeDimensions(drawingId, rDimensionIds);
+                    }, ...dimensionIds);
+                },
+                linearPattern: (partId, entities, references1, params1, references2, params2) => {
+                    return this.resolve(async ([rPartId, rEntities, rReferences1, rReferences2]) => {
+                        const patternId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCLinearPattern, 'LinearPattern');
+                        if (patternId != null) {
+                            // entities
+                            const cDrawing = await (0, core_1.getDrawing)(drawingId);
+                            const entArray = [];
+                            for (const rEntity of rEntities) {
+                                const entity = cDrawing.structure.tree[(await rEntity)].children;
+                                if (entity != undefined) {
+                                    entArray.push(entity[0]);
+                                }
+                            }
+                            const distance1Param = {
+                                value: params1.distance,
+                                isExpr: typeof params1.distance === 'string',
+                            };
+                            const count1Param = {
+                                value: params1.count,
+                                isExpr: typeof params1.count === 'string',
+                            };
+                            const params1Param = [
+                                params1.inverted,
+                                distance1Param,
+                                count1Param,
+                                params1.merged,
+                            ];
+                            let params2Param = null;
+                            if (params2) {
+                                const distance2Param = {
+                                    value: params2.distance,
+                                    isExpr: typeof params2.distance === 'string',
+                                };
+                                const count2Param = {
+                                    value: params2.count,
+                                    isExpr: typeof params2.count === 'string',
+                                };
+                                params2Param = [params2.inverted, distance2Param, count2Param];
+                            }
+                            // resolve references1
+                            const refs1 = [];
+                            let refs2 = [];
+                            for (const rRef1 of rReferences1) {
+                                refs1.push(await rRef1);
+                            }
+                            // resolve references2 if present
+                            if (rReferences2) {
+                                for (const rRef2 of rReferences2) {
+                                    refs2.push(await rRef2);
+                                }
+                            }
+                            else {
+                                refs2 = null;
+                            }
+                            await featureAPI.updatePattern(drawingId, patternId, entArray, refs1, params1Param, refs2, params2Param);
+                            return patternId;
+                        }
+                        return null;
+                    }, partId, entities, references1, references2);
+                },
+                circularPattern: (partId, entities, references, params) => {
+                    return this.resolve(async ([rPartId, rEntities, ...rReferences]) => {
+                        const patternId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCCircularPattern, 'CircularPattern');
+                        if (patternId != null) {
+                            // entities
+                            const cDrawing = await (0, core_1.getDrawing)(drawingId);
+                            const entArray = [];
+                            for (const rEntity of rEntities) {
+                                const entity = cDrawing.structure.tree[(await rEntity)].children;
+                                if (entity != undefined) {
+                                    entArray.push(entity[0]);
+                                }
+                            }
+                            const angleParam = { value: params.angle, isExpr: typeof params.angle === 'string' };
+                            const countParam = { value: params.count, isExpr: typeof params.count === 'string' };
+                            const paramsParam = [
+                                params.inverted,
+                                angleParam,
+                                countParam,
+                                params.merged,
+                            ];
+                            rReferences = Array.isArray(rReferences) ? rReferences : [rReferences];
+                            await featureAPI.updatePattern(drawingId, patternId, entArray, rReferences, paramsParam, null, null);
+                            return patternId;
+                        }
+                        return null;
+                    }, partId, entities, ...references);
+                },
+                extrusion: (partId, sketchId, type, limit1, limit2, taperAngle, direction, capEnds) => {
+                    return this.resolve(async ([rPartId, rSketchId]) => {
+                        const extrusion = await featureAPI.createExtrusion(drawingId, rPartId);
+                        if (extrusion) {
+                            const cDrawing = await (0, core_1.getDrawing)(drawingId);
+                            const sketchLines = [];
+                            // TODO: Which sketch lines need to be included, is CCClasses.CCCurve and its derivation enough?
+                            sketchLines.push(...classcad_1.ccUtils.base.getChildren(rSketchId, classcad_1.CCClasses.CCCurve, cDrawing.structure.tree));
+                            if (sketchLines) {
+                                const limit1Param = { value: limit1, isExpr: typeof limit1 === 'string' };
+                                const limit2Param = { value: limit2, isExpr: typeof limit2 === 'string' };
+                                const taperAngleParam = {
+                                    value: taperAngle,
+                                    isExpr: typeof taperAngle === 'string',
+                                };
+                                const directionParam = {
+                                    value: direction,
+                                    isExpr: typeof direction === 'string',
+                                };
+                                await featureAPI.updateExtrusion(drawingId, extrusion, sketchLines, type, limit1Param, limit2Param, taperAngleParam, directionParam, capEnds);
+                                return extrusion;
+                            }
+                        }
+                    }, partId, sketchId);
+                },
+                revolve: (partId, sketchId, axisIds, angle1, angle2, inverted) => {
+                    return this.resolve(async ([rPartId, rSketchId, ...rAxisIds]) => {
+                        const revolve = await featureAPI.createRevolve(drawingId, rPartId);
+                        if (revolve) {
+                            const cDrawing = await (0, core_1.getDrawing)(drawingId);
+                            const sketchLines = [];
+                            sketchLines.push(...classcad_1.ccUtils.base.getChildren(rSketchId, classcad_1.CCClasses.CCCircle, cDrawing.structure.tree));
+                            sketchLines.push(...classcad_1.ccUtils.base.getChildren(rSketchId, classcad_1.CCClasses.CCLine, cDrawing.structure.tree));
+                            if (sketchLines) {
+                                const angle1Param = { value: angle1, isExpr: typeof angle1 === 'string' };
+                                const angle2Param = { value: angle2, isExpr: typeof angle2 === 'string' };
+                                await featureAPI.updateRevolve(drawingId, revolve, sketchLines, rAxisIds, angle1Param, angle2Param, inverted);
+                                return revolve;
+                            }
+                        }
+                    }, partId, sketchId, ...axisIds);
+                },
+                boolean: (partId, type, entities) => {
+                    return this.resolve(async ([rPartId, rEntities]) => {
+                        const cDrawing = await (0, core_1.getDrawing)(drawingId);
+                        const entArray = [];
+                        for (const rEntity of rEntities) {
+                            const entity = cDrawing.structure.tree[(await rEntity)].children;
+                            if (entity != undefined) {
+                                entArray.push(entity[0]);
+                            }
+                        }
+                        const boolId = await featureAPI.createBooleanOperation(drawingId, rPartId, {
+                            type,
+                            entities: entArray,
+                        });
+                        if (boolId != null) {
+                            await featureAPI.updateBooleanOperation(drawingId, boolId, type, entArray);
+                            return boolId;
+                        }
+                        return null;
+                    }, partId, entities);
+                },
+                box: (partId, references, width, length, height) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const boxId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCBox, 'Box');
+                        if (boxId != null) {
+                            const widthParam = { value: width, isExpr: typeof width === 'string' };
+                            const lengthParam = { value: length, isExpr: typeof length === 'string' };
+                            const heightParam = { value: height, isExpr: typeof height === 'string' };
+                            await featureAPI.updateBox(drawingId, boxId, rReferences, widthParam, lengthParam, heightParam);
+                            return boxId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                cylinder: (partId, references, diameter, height) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const cylId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCCylinder, 'Cylinder');
+                        if (cylId != null) {
+                            const diameterParam = { value: diameter, isExpr: typeof diameter === 'string' };
+                            const heightParam = { value: height, isExpr: typeof height === 'string' };
+                            await featureAPI.updateCylinder(drawingId, cylId, rReferences, diameterParam, heightParam);
+                            return cylId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                chamfer: (partId, type, references, dist1, dist2, angle) => {
+                    return this.resolve(async ([rPartId, rReferences]) => {
+                        const dist1Param = { value: dist1, isExpr: typeof dist1 === 'string' };
+                        const dist2Param = { value: dist2, isExpr: typeof dist2 === 'string' };
+                        const angleParam = { value: angle, isExpr: typeof angle === 'string' };
+                        const chamferId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCChamfer, 'Chamfer');
+                        if (chamferId != null) {
+                            await featureAPI.updateChamfer(drawingId, chamferId, type, rReferences, dist1Param, dist2Param, angleParam);
+                            return chamferId;
+                        }
+                        return null;
+                    }, partId, references);
+                },
+                cone: (partId, references, bDiameter, tDiameter, height) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const coneId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCCone, 'Cone');
+                        if (coneId != null) {
+                            const bDiamParam = { value: bDiameter, isExpr: typeof bDiameter === 'string' };
+                            const tDiamParam = { value: tDiameter, isExpr: typeof tDiameter === 'string' };
+                            const heightParam = { value: height, isExpr: typeof height === 'string' };
+                            await featureAPI.updateCone(drawingId, coneId, rReferences, bDiamParam, tDiamParam, heightParam);
+                            return coneId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                createFastenedConstraint: async (asmId, mate1, mate2, xOffset, yOffset, zOffset, name) => {
+                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
+                    const constraintId = await classcad_1.ccAPI.assemblyBuilder.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCFastenedConstraint, name);
+                    if (constraintId != null) {
+                        const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
+                        const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
+                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
+                        await classcad_1.ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, constraintId, { matePath: rMatePath1, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, { matePath: rMatePath2, wcsId: rWcs2, flip: mate2.flip, reoriented: mate2.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateFastenedConstraint: async (constrId, mate1, mate2, xOffset, yOffset, zOffset) => {
+                    const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constrId, mate1.wcsId, mate2.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
+                    const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
+                    const yOffsetParam = { value: yOffset, isExpr: typeof xOffset === 'string' };
+                    const zOffsetParam = { value: zOffset, isExpr: typeof xOffset === 'string' };
+                    await classcad_1.ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, rConstrId, { matePath: rMatePath1, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, { matePath: rMatePath2, wcsId: rWcs2, flip: mate2.flip, reoriented: mate2.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
+                },
+                updateFastenedConstraints: async (...constraints) => {
+                    var e_3, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_1 = __asyncValues(constraints), constraints_1_1; constraints_1_1 = await constraints_1.next(), !constraints_1_1.done;) {
+                            const constr = constraints_1_1.value;
+                            const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId, constr.mate2.wcsId));
+                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
+                            const xOffsetParam = { value: constr.xOffset, isExpr: typeof constr.xOffset === 'string' };
+                            const yOffsetParam = { value: constr.yOffset, isExpr: typeof constr.yOffset === 'string' };
+                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: constr.mate2.flip,
+                                    reoriented: constr.mate2.reoriented,
+                                },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffset: zOffsetParam,
+                            });
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (constraints_1_1 && !constraints_1_1.done && (_a = constraints_1.return)) await _a.call(constraints_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    await classcad_1.ccAPI.assemblyBuilder.updateFastenedConstraints(drawingId, constrToAdd);
+                },
+                createFastenedOriginConstraint: async (asmId, mate1, xOffset, yOffset, zOffset, name) => {
+                    const [rAsmId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId));
+                    const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const constraintId = await classcad_1.ccAPI.assemblyBuilder.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCFastenedOriginConstraint, name);
+                    if (constraintId != null) {
+                        const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
+                        const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
+                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
+                        await classcad_1.ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, constraintId, { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateFastenedOriginConstraint: async (constrId, mate1, xOffset, yOffset, zOffset) => {
+                    const [rConstrId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), constrId, mate1.wcsId));
+                    const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
+                    const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
+                    const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
+                    await classcad_1.ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, rConstrId, { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
+                },
+                updateFastenedOriginConstraints: async (...constraints) => {
+                    var e_4, _a;
+                    const constraintsToAdd = [];
+                    try {
+                        for (var constraints_2 = __asyncValues(constraints), constraints_2_1; constraints_2_1 = await constraints_2.next(), !constraints_2_1.done;) {
+                            const constr = constraints_2_1.value;
+                            const [rConstrId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId));
+                            const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const xOffsetParam = { value: constr.xOffset, isExpr: typeof constr.xOffset === 'string' };
+                            const yOffsetParam = { value: constr.yOffset, isExpr: typeof constr.yOffset === 'string' };
+                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
+                            constraintsToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffset: zOffsetParam,
+                            });
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (constraints_2_1 && !constraints_2_1.done && (_a = constraints_2.return)) await _a.call(constraints_2);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                    await classcad_1.ccAPI.assemblyBuilder.updateFastenedOriginConstraints(drawingId, constraintsToAdd);
+                },
+                createBufferGeometry: async (objectId) => {
+                    await this.queue;
+                    this.queue = Promise.resolve(0);
+                    const rObjectId = await objectId;
+                    const cDrawing = (0, core_1.getDrawing)(drawingId);
+                    const structureTree = cDrawing.structure.tree;
+                    const bufferGeomArray = [];
+                    if (rObjectId != null) {
+                        const rootObj = structureTree[rObjectId];
+                        await createRecursiveBufferGeometry(rootObj, drawingId, bufferGeomArray);
+                        if (bufferGeomArray.length > 0) {
+                            return bufferGeomArray;
+                        }
+                    }
+                    return undefined;
+                },
+                createScene: async (objectId, options) => {
+                    await this.queue;
+                    this.queue = Promise.resolve(0);
+                    const rObjectId = await objectId;
+                    const cDrawing = (0, core_1.getDrawing)(drawingId);
+                    const structureTree = cDrawing.structure.tree;
+                    const scene = new three_1.Scene();
+                    if (rObjectId != null) {
+                        const rootObj = structureTree[rObjectId];
+                        if (rootObj) {
+                            await createRecursiveScene(rootObj, drawingId, scene, options);
+                        }
+                        else {
+                            throw new Error('Root object does not exist!');
+                        }
+                    }
+                    return scene;
+                },
+                createExpressions: (partId, ...members) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const membersToAdd = [];
+                        members.forEach(mem => {
+                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
+                            const dataType = classcad_1.DataType.REAL; // TODO: Aktuell nur Real Werte als Expression
+                            const featureAPIParam = {
+                                value: mem.value,
+                                isExpr: isExpr,
+                            };
+                            membersToAdd.push({ name: mem.name, value: featureAPIParam, dataType });
+                        });
+                        const success = featureAPI.updateExpressionSet(drawingId, rPartId, membersToAdd, [], []);
+                        return success;
+                    }, partId);
+                },
+                createAssemblyAsTemplate: (name) => {
+                    return this.resolve(async ([]) => {
+                        return await classcad_1.ccAPI.assemblyBuilder.createAssemblyAsTemplate(drawingId, name);
+                    });
+                },
+                createRootAssembly: (name) => {
+                    return this.resolve(async ([]) => {
+                        return await classcad_1.ccAPI.assemblyBuilder.createRootAssembly(drawingId, name);
+                    });
+                },
+                createPart: (name) => {
+                    return this.resolve(async ([]) => {
+                        const partName = name ? name : 'Part';
+                        return await featureAPI.newPart(drawingId, partName);
+                    });
+                },
+                createPartAsTemplate: (name) => {
+                    return this.resolve(async ([]) => {
+                        const partName = name ? name : 'Part';
+                        return await classcad_1.ccAPI.assemblyBuilder.createPartAsTemplate(drawingId, partName);
+                    });
+                },
+                createWorkAxis: (partId, type, references, position, direction, local, name) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const wAName = name ? name : 'WorkAxis';
+                        const wAId = await featureAPI.createWorkGeometry(drawingId, rPartId, classcad_1.CCClasses.CCWorkAxis, wAName);
+                        if (wAId != null) {
+                            const positionParam = {
+                                value: position,
+                                isExpr: typeof position === 'string',
+                            };
+                            const directionParam = {
+                                value: direction,
+                                isExpr: typeof direction === 'string',
+                            };
+                            await featureAPI.updateWorkAxis(drawingId, wAId, type, rReferences, positionParam, directionParam, local);
+                            return wAId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                createWorkCoordSystem: (partId, type, references, coordinateSystem, offset, rotation, inverted, local, name) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const wCSName = name ? name : 'WorkCoordSystem';
+                        const wCSId = await featureAPI.createWorkGeometry(drawingId, rPartId, classcad_1.CCClasses.CCWorkCoordSystem, wCSName);
+                        if (wCSId != null) {
+                            const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
+                            const rotationParam = {
+                                value: rotation,
+                                isExpr: typeof rotation === 'string',
+                            };
+                            await featureAPI.updateWorkCoordSystem(drawingId, wCSId, type, rReferences, coordinateSystem, offsetParam, rotationParam, inverted, local);
+                            return wCSId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const wPName = name ? name : 'WorkPlane';
+                        const wPId = await featureAPI.createWorkGeometry(drawingId, rPartId, classcad_1.CCClasses.CCWorkPlane, wPName);
+                        if (wPId != undefined) {
+                            const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
+                            const angleParam = { value: angle, isExpr: typeof angle === 'string' };
+                            const positionParam = {
+                                value: position,
+                                isExpr: typeof position === 'string',
+                            };
+                            const normalParam = { value: normal, isExpr: typeof normal === 'string' };
+                            await featureAPI.updateWorkPlane(drawingId, wPId, type, rReferences, offsetParam, angleParam, positionParam, normalParam, local);
+                            return wPId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                createWorkPoint: (partId, type, references, position, local, name) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const wPTName = name ? name : 'WorkPoint';
+                        const wPTId = await featureAPI.createWorkGeometry(drawingId, rPartId, classcad_1.CCClasses.CCWorkPoint, wPTName);
+                        if (wPTId != undefined) {
+                            const positionParam = {
+                                value: position,
+                                isExpr: typeof position === 'string',
+                            };
+                            await featureAPI.updateWorkPoint(drawingId, wPTId, type, rReferences, positionParam, local);
+                            return wPTId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                fillet: (partId, references, radius) => {
+                    return this.resolve(async ([rPartId, rReferences]) => {
+                        const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
+                        const filletId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCConstantRadiusFillet, 'Fillet');
+                        if (filletId != null) {
+                            await featureAPI.updateFillet(drawingId, filletId, rReferences, radiusParam);
+                            return filletId;
+                        }
+                        return null;
+                    }, partId, references);
+                },
+                findOrSelect: (partId, type, length, positions) => {
+                    return this.resolve(async ([rPartId]) => {
+                        let filter = core_1.lineSegmentsFilter;
+                        switch (type) {
+                            case 0: // Vertex
+                                filter = core_1.pointFilter;
+                                break;
+                            case 1: // Edge
+                                filter = core_1.lineSegmentsFilter;
+                                break;
+                            case 2: // Loop
+                                filter = core_1.loopFilter;
+                                break;
+                            case 3: // Face
+                                filter = core_1.planeFilter;
+                                break;
+                        }
+                        const geometries = positions
+                            ? await classcad_1.ccAPI.geometry.findGeometriesByPoints(drawingId, rPartId, type, positions)
+                            : await (0, selection_1.waitForSelect)(length, filter, (resolveSelection, items, diff) => {
+                                if (items.length > length - 1) {
+                                    resolveSelection(items.map(i => i.data.graphicId));
+                                    classcad_1.ccAPI.geometry
+                                        .getPointsByGeometries(drawingId, items.map(i => i.data.graphicId))
+                                        .then(points => {
+                                        logPoints(points);
+                                    });
+                                }
+                            });
+                        return geometries;
+                    }, partId);
+                },
+                getAssemblyFromContainer: (asmName) => {
+                    return this.resolve(async ([]) => {
+                        const asmIds = classcad_1.ccUtils.assembly.getAssemblyFromContainer(drawingId, asmName);
+                        if (asmIds != undefined) {
+                            return Array.isArray(asmIds) ? asmIds : [asmIds];
+                        }
+                        return null;
+                    });
+                },
+                getAssemblyNode: (refId, nodeName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const nodeIds = classcad_1.ccUtils.assembly.getAssemblyNode(drawingId, rRefId, nodeName);
+                        if (nodeIds != undefined) {
+                            return Array.isArray(nodeIds) ? nodeIds : [nodeIds];
+                        }
+                        return null;
+                    }, refId);
+                },
+                setCurrentNode: (refId) => {
+                    return this.resolve(async ([rRefId]) => {
+                        await classcad_1.ccAPI.assemblyBuilder.setCurrentNode(drawingId, rRefId);
+                    }, refId);
+                },
+                getCurrentNode: () => {
+                    return this.resolve(async () => {
+                        const drw = (0, core_1.getDrawing)(drawingId);
+                        return drw.structure.currentNode;
+                    });
+                },
+                getCoordSysFromNode: (refId) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const coordSys = classcad_1.ccUtils.assembly.getCoordSysFromNode(drawingId, rRefId);
+                        if (coordSys != undefined) {
+                            return coordSys;
+                        }
+                        return null;
+                    }, refId);
+                },
+                setCurrentProduct: (productId) => {
+                    return this.resolve(async ([rProductId]) => {
+                        await classcad_1.ccAPI.baseModeler.setCurrentProduct(drawingId, rProductId);
+                    }, productId);
+                },
+                getCurrentProduct: () => {
+                    return this.resolve(async () => {
+                        const drw = (0, core_1.getDrawing)(drawingId);
+                        return drw.structure.currentProduct;
+                    });
+                },
+                getPartFromContainer: (partName) => {
+                    return this.resolve(async ([]) => {
+                        const partIds = classcad_1.ccUtils.assembly.getPartFromContainer(drawingId, partName);
+                        if (partIds != undefined) {
+                            return Array.isArray(partIds) ? partIds : [partIds];
+                        }
+                        return null;
+                    });
+                },
+                getWorkCoordSystem: (refId, wcsName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const wcsIds = classcad_1.ccUtils.assembly.getWorkCoordSystem(drawingId, rRefId, wcsName);
+                        if (wcsIds != undefined) {
+                            return Array.isArray(wcsIds) ? wcsIds : [wcsIds];
+                        }
+                        return null;
+                    }, refId);
+                },
+                getConstraint: (refId, constrName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const constrIds = classcad_1.ccUtils.assembly.getConstraint(drawingId, rRefId, constrName);
+                        if (constrIds != undefined) {
+                            return Array.isArray(constrIds) ? constrIds : [constrIds];
+                        }
+                        return null;
+                    }, refId);
+                },
+                getFeatureByName: (partId, featureName) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const feature = await featureAPI.getFeatureByName(drawingId, rProductId, featureName);
+                        if (feature !== null) {
+                            return feature;
+                        }
+                        return null;
+                    }, partId);
+                },
+                removeNode: (referenceId, ownerId) => {
+                    return this.resolve(async ([rReferenceId, rOwnerId]) => {
+                        await classcad_1.ccAPI.assemblyBuilder.removeNode(drawingId, rReferenceId, rOwnerId);
+                    }, referenceId, ownerId);
+                },
+                removeNodes: (...nodes) => {
+                    return this.resolve(async ([...rNodes]) => {
+                        const nodesToRemove = [];
+                        rNodes.forEach(node => {
+                            nodesToRemove.push([node.referenceId, node.ownerId]);
+                        });
+                        return classcad_1.ccAPI.assemblyBuilder.removeNodes(drawingId, nodesToRemove);
+                    }, ...nodes);
+                },
+                importFeature: (partId, content, format, name) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const featureName = name ? name : 'Import';
+                        const importFeatureId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCImport, featureName);
+                        if (importFeatureId !== null) {
+                            const solids = await featureAPI.updateImport(drawingId, importFeatureId, content, format, featureName);
+                            if (solids !== null) {
+                                return importFeatureId;
+                            }
+                        }
+                        return null;
+                    }, partId);
+                },
+                loadSketch: (partId, stream, planeId, name) => {
+                    return this.resolve(async ([rPartId, rPlaneId]) => {
+                        const sketch = await sketcherAPI.createSketch(drawingId, rPartId);
+                        if (sketch) {
+                            await featureAPI.closeFeature(drawingId, sketch);
+                            const tree = (0, core_1.getDrawing)(drawingId).structure.tree;
+                            const plane = tree[rPlaneId];
+                            if (plane && base.isA(plane.class, classcad_1.CCClasses.CCWorkPlane)) {
+                                await sketcherAPI.setWorkPlane(drawingId, sketch, rPlaneId);
+                            }
+                            else {
+                                await sketcherAPI.createAndSetWorkPlane(drawingId, sketch, rPlaneId);
+                            }
+                            await sketcherAPI.loadSketch(drawingId, rPartId, sketch, stream, name);
+                            return sketch;
+                        }
+                    }, partId, planeId);
+                },
+                copySketch: (partId, sketchId, planeId) => {
+                    return this.resolve(async ([rPartId, rPlaneId, rSketchId]) => {
+                        const sketch = await sketcherAPI.createSketch(drawingId, rPartId);
+                        if (sketch) {
+                            await featureAPI.closeFeature(drawingId, sketch);
+                            const tree = (0, core_1.getDrawing)(drawingId).structure.tree;
+                            const plane = tree[rPlaneId];
+                            if (plane && base.isA(plane.class, classcad_1.CCClasses.CCWorkPlane)) {
+                                await sketcherAPI.setWorkPlane(drawingId, sketch, rPlaneId);
+                            }
+                            else {
+                                await sketcherAPI.createAndSetWorkPlane(drawingId, sketch, rPlaneId);
+                            }
+                            await sketcherAPI.copySketch(drawingId, sketch, rSketchId);
+                            return sketch;
+                        }
+                    }, partId, planeId, sketchId);
+                },
+                placeSketch: (sketchId, planeId, invertPlane, axisId, isXAxis, invertAxis, originId) => {
+                    return this.resolve(async ([rSketchId, rPlaneId, rAxisId, rOriginId]) => {
+                        await sketcherAPI.setSketchRefs(drawingId, rSketchId, rPlaneId, invertPlane, rAxisId, isXAxis, invertAxis, rOriginId);
+                    }, sketchId, planeId, axisId, originId);
+                },
+                transformNode: (referenceId, ownerId, transformation) => {
+                    return this.resolve(async ([rRefId, rOwnerId]) => {
+                        await classcad_1.ccAPI.assemblyBuilder.setNodeTransformation(drawingId, rRefId, rOwnerId, transformation);
+                    }, referenceId, ownerId);
+                },
+                translate: (partId, featureIds, references, inverted, distance) => {
+                    return this.resolve(async ([rPartId, rFeatureIds, ...rReferences]) => {
+                        const translationId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCTranslation, 'Translate');
+                        if (translationId !== null) {
+                            const cDrawing = await (0, core_1.getDrawing)(drawingId);
+                            const entArray = [];
+                            for (const rFeatureId of rFeatureIds) {
+                                const entity = cDrawing.structure.tree[(await rFeatureId)].children;
+                                if (entity != undefined) {
+                                    entArray.push(entity[0]);
+                                }
+                            }
+                            const dist = { value: distance, isExpr: typeof distance === 'string' };
+                            await featureAPI.updateTransformation(drawingId, translationId, entArray, rReferences, inverted, dist);
+                            return translationId;
+                        }
+                        return null;
+                    }, partId, featureIds, ...references);
+                },
+                // TODO: Remove this method. Is it necessary?
+                updateTranslate: (translationId, distance) => {
+                    return this.resolve(async ([rTranslationId]) => {
+                        const cDrawing = await (0, core_1.getDrawing)(drawingId);
+                        const members = cDrawing.structure.tree[rTranslationId].members;
+                        if (members !== null && members !== undefined) {
+                            const entArray = members['bodiesToTransform'].members.map(m => m.value);
+                            const references = members['references'].members.map(m => m.value);
+                            const inverted = members['inverted'].value;
+                            const dist = distance !== null ? distance : members['translationDistance'].value;
+                            const distParam = { value: dist, isExpr: typeof distance === 'string' };
+                            await featureAPI.openFeature(drawingId, rTranslationId);
+                            await featureAPI.updateTransformation(drawingId, rTranslationId, entArray, references, inverted, distParam);
+                            await featureAPI.closeFeature(drawingId, rTranslationId);
+                        }
+                    }, translationId);
+                },
+                save: (type) => {
+                    return classcad_1.ccAPI.baseModeler.save(drawingId, type);
+                },
+                saveToUrl: (url, filetype) => {
+                    return classcad_1.ccAPI.baseModeler.saveToUrl(drawingId, url, filetype);
+                },
+                load: (content, type) => {
+                    return classcad_1.ccAPI.baseModeler.load(drawingId, content, type);
+                },
+                loadFromUrl: (url, filetype) => {
+                    return classcad_1.ccAPI.baseModeler.loadFromUrl(drawingId, url, filetype, true);
+                },
+                loadProduct: (content, type) => {
+                    return classcad_1.ccAPI.assemblyBuilder.loadProduct(drawingId, content, type);
+                },
+                loadProductFromUrl: (url, filetype) => {
+                    return classcad_1.ccAPI.assemblyBuilder.loadProductFromUrl(drawingId, url, filetype);
+                },
+                pick: (partId, type, points) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const refs = await featureAPI.pick(drawingId, rPartId, type, points);
+                        if (refs != undefined) {
+                            return Array.isArray(refs) ? refs : [refs];
+                        }
+                        return null;
+                    }, partId);
+                },
+                setExpressions: (partId, ...members) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const membersToModify = [];
+                        members.forEach(mem => {
+                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen Strings
+                            const featureAPIParam = {
+                                value: mem.value,
+                                isExpr,
+                            };
+                            membersToModify.push({ name: mem.name, value: featureAPIParam });
+                        });
+                        const success = featureAPI.updateExpressionSet(drawingId, rPartId, [], membersToModify, []);
+                        return success;
+                    }, partId);
+                },
+                setExpressionSets: (...exprSets) => {
+                    return this.resolve(async ([...rExprSets]) => {
+                        const exprSetsToSet = [];
+                        rExprSets.forEach(exprSet => {
+                            const membersToModify = [];
+                            exprSet.members.forEach((mem) => {
+                                const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen Strings
+                                const featureAPIParam = {
+                                    value: mem.value,
+                                    isExpr,
+                                };
+                                membersToModify.push({ name: mem.name, value: featureAPIParam });
+                            });
+                            exprSetsToSet.push({
+                                productId: exprSet.partId,
+                                toAddMembers: [],
+                                toModifyMembers: membersToModify,
+                                toDeleteList: [],
+                            });
+                        });
+                        const success = await featureAPI.updateExpressionSets(drawingId, exprSetsToSet);
+                        return success;
+                    }, ...exprSets);
+                },
+                deleteExpressions: (partId, members) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const success = featureAPI.updateExpressionSet(drawingId, rPartId, [], [], members);
+                        return success;
+                    }, partId);
+                },
+                sphere: (partId, references, radius) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const sphereId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCSphere, 'Sphere');
+                        if (sphereId != null) {
+                            const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
+                            await featureAPI.updateSphere(drawingId, sphereId, rReferences, radiusParam);
+                            return sphereId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+            };
+            callback(publicApi);
+            resolve(drawingId);
+        });
+        return () => promise.then(drawingId => core_1.api.getState().api.removeDrawing(drawingId));
+    }
+    destroy() {
+        this.drawingId && core_1.api.getState().api.removeDrawing(this.drawingId);
+    }
+}
+exports.default = CAD;