@buerli.io/headless 0.2.1 → 0.3.0

package/build/history.js

@@ -1,39 +1,21 @@
 /* eslint-disable max-lines */
-import { BooleanOperationType, ccAPI, CCClasses, ccUtils, ChamferType, DataType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, OrientationType, } from '@buerli.io/classcad';
-import { api, getDrawing, MathUtils, } from '@buerli.io/core';
+import { ccAPI, CCClasses, ccUtils, DataType, } from '@buerli.io/classcad';
+import { api, getDrawing, lineSegmentsFilter, loopFilter, MathUtils, planeFilter, pointFilter, } from '@buerli.io/core';
 import { Group, Mesh, MeshStandardMaterial, Scene, Vector3 } from 'three';
 import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUtils';
+import { waitForSelect } from './utils/selection';
 const featureAPI = ccAPI.feature;
+const sketcherAPI = ccAPI.sketcher;
+const base = ccUtils.base;
 let BufferGeometryUtils = BufferGeometryUtils_;
 if (BufferGeometryUtils.BufferGeometryUtils) {
     BufferGeometryUtils = BufferGeometryUtils.BufferGeometryUtils;
 }
-// Qeued execute, returns the first result and expects it to be an ObjectID
-const exec = (instance, drawing, namespace, fn, stream, ...args) => {
-    return (instance.queue = instance.queue.then(() => Promise.all(args).then(resolvedArgs => {
-        return ccAPI.base.callSafeAPI(drawing, namespace, fn, resolvedArgs, stream).then(res => {
-            return (res && res.results[0].result);
-        });
-    })));
-};
-const toCCVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
-const toArray = (v) => (Array.isArray(v) ? v : v.toArray());
-const toEuler = (v) => toArray(v);
-const makeVec = (v) => toCCVec(toArray(v));
-const getBoxMember = (drawingId, featureId, member) => {
-    const cDrawing = getDrawing(drawingId);
-    const members = cDrawing.structure.tree[featureId].members;
-    if (members) {
-        switch (member) {
-            case 'width':
-                return members.width.value === undefined ? 10 : Number(members.width.value);
-            case 'length':
-                return members.length.value === undefined ? 10 : Number(members.length.value);
-            case 'height':
-                return members.height.value === undefined ? 10 : Number(members.height.value);
-        }
-    }
-};
+/**
+ * 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':
@@ -44,136 +26,11 @@ const getDataType = (value) => {
             return DataType.STRING;
     }
 };
-const getBoolType = (type) => {
-    switch (type) {
-        case 'Union':
-            return BooleanOperationType.UNION;
-        case 'Subtraction':
-            return BooleanOperationType.SUBTRACTION;
-        case 'Intersection':
-            return BooleanOperationType.INTERSECTION;
-        case undefined:
-            break;
-    }
-};
-const getChamferType = (type) => {
-    switch (type) {
-        case 'Equal_Distance':
-            return ChamferType.EQUAL_DISTANCE;
-        case 'Two_Distances':
-            return ChamferType.TWO_DISTANCES;
-        case 'Distance_And_Angle':
-            return ChamferType.DISTANCE_AND_ANGLE;
-        case undefined:
-            break;
-    }
-};
-const getWCSType = (type) => {
-    switch (type) {
-        case 'XYAxisOrigin':
-            return WorkCoordSystemType.WCS_XYAXISORIGIN;
-        case 'Custom':
-            return WorkCoordSystemType.WCS_CUSTOM;
-        case undefined:
-            break;
-    }
-};
-const getWAType = (type) => {
-    switch (type) {
-        case 'Custom':
-            return WorkAxisType.WA_USERDEFINED;
-        case 'WorkPoints':
-            return WorkAxisType.WA_WORKPOINTS;
-        case 'PointAndDirection':
-            return WorkAxisType.WA_POINTDIRECTION;
-        case 'SketchLine':
-            return WorkAxisType.WA_SKETCHLINE;
-        case 'Curve':
-            return WorkAxisType.WA_CURVE;
-        case '2Points':
-            return WorkAxisType.WA_2POINTS;
-        case '2Planes':
-            return WorkAxisType.WA_2PLANES;
-        case undefined:
-            break;
-    }
-};
-const getWPType = (type) => {
-    switch (type) {
-        case 'Custom':
-            return WorkPlaneType.WP_USERDEFINED;
-        case 'Plane':
-            return WorkPlaneType.WP_PLANE;
-        case 'EdgeAndPoint':
-            return WorkPlaneType.WP_EDGEPOINT;
-        case '3Points':
-            return WorkPlaneType.WP_3POINTS;
-        case 'PointAndNormal':
-            return WorkPlaneType.WP_POINTNORMAL;
-        case 'PointAndFace':
-            return WorkPlaneType.WP_POINTFACE;
-        case 'LinePlaneAndAngle':
-            return WorkPlaneType.WP_LINEPLANEANGLE;
-        case undefined:
-            break;
-    }
-};
-const getWPTType = (type) => {
-    switch (type) {
-        case 'Custom':
-            return WorkPointType.WPT_USERDEFINED;
-        case 'Point':
-            return WorkPointType.WPT_BREPVERTEX;
-        case 'MidPointLine':
-            return WorkPointType.WPT_EDGEMIDPOINT;
-        case 'Center':
-            return WorkPointType.WPT_CENTER;
-        case 'BaryCenter':
-            return WorkPointType.WPT_BARYCENTER;
-        case 'Intersection':
-            return WorkPointType.WPT_INTERSECTION;
-        case 'InnerCircle':
-            return WorkPointType.WPT_INNERCIRCLE;
-        case 'MidPointOf2Points':
-            return WorkPointType.WPT_2POINTS;
-        case undefined:
-            break;
-    }
-};
-const getViewType = (type) => {
-    switch (type) {
-        case 'Top':
-            return ViewType.TOP;
-        case 'Front':
-            return ViewType.FRONT;
-        case 'Right':
-            return ViewType.RIGHT;
-        case 'Left':
-            return ViewType.LEFT;
-        case 'Bottom':
-            return ViewType.BOTTOM;
-        case 'Right_90°':
-            return ViewType.RIGHT_90;
-        case 'Left_90°':
-            return ViewType.LEFT_90;
-        case 'Back':
-            return ViewType.BACK;
-        case 'Iso':
-            return ViewType.ISO;
-        case undefined:
-            break;
-    }
-};
-const getOrientationType = (type) => {
-    switch (type) {
-        case 'Vertical':
-            return OrientationType.VERTICAL;
-        case 'Horizontal':
-            return OrientationType.HORIZONTAL;
-        case undefined:
-            break;
-    }
-};
+/**
+ * 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) => {
     switch (type) {
         case 'LinearDimension':
@@ -182,6 +39,13 @@ const getDimensionType = (type) => {
             break;
     }
 };
+/**
+ * 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 = ccUtils.assembly.getCoordSysFromNode(drawingId, ownerId);
@@ -202,6 +66,11 @@ const getGlobalTransformation = (drawingId, ownerId, localTransformation) => {
     }
     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 = getDrawing(drawingId);
     const tree = cDrawing.structure.tree;
@@ -359,6 +228,28 @@ const getDifferentColoredMeshesFromSolid = (solid) => {
     });
     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);
+    }
+};
 export default class CAD {
     constructor() {
         this.drawingId = null;
@@ -366,7 +257,11 @@ export default class CAD {
         this.queue = Promise.resolve(0);
     }
     resolve(callback, ...args) {
-        return (this.queue = this.queue.then(() => Promise.all(args).then(callback)));
+        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) => {
@@ -382,21 +277,19 @@ export default class CAD {
                     }, productId, ownerId);
                 },
                 addNodes: (...nodes) => {
-                    return this.resolve(async ([]) => {
+                    return this.resolve(async ([...rNodes]) => {
                         const nodesToAdd = [];
-                        nodes.forEach(node => {
+                        rNodes.forEach(node => {
                             const globalTransformation = getGlobalTransformation(drawingId, node.ownerId, node.transformation) || node.transformation;
                             nodesToAdd.push([node.productId, node.ownerId, globalTransformation, node.name]);
                         });
                         return ccAPI.assemblyBuilder.addNodes(drawingId, nodesToAdd);
-                    });
+                    }, ...nodes);
                 },
                 addDimension: (dim) => {
                     return this.resolve(async ([rProductId]) => {
-                        const orientation = getOrientationType(dim.dimParam.dimOrientation);
-                        const view = getViewType(dim.dxfView);
                         const dimensionType = getDimensionType(dim.dimParam.dimType);
-                        if (orientation !== undefined && view !== undefined) {
+                        if (dim.dimParam.dimOrientation !== undefined && dim.dxfView !== undefined) {
                             const dimParam = [
                                 rProductId,
                                 [
@@ -408,24 +301,22 @@ export default class CAD {
                                     dim.dimParam.dimEndPos,
                                     dim.dimParam.dimTextPos,
                                     dim.dimParam.dimTextAngle,
-                                    orientation,
+                                    dim.dimParam.dimOrientation,
                                     dim.dimParam.dimColor || 256,
                                     dim.dimParam.dimLayer || '2', // which layer makes sense as default?
                                 ],
-                                view,
+                                dim.dxfView,
                             ];
                             return ccAPI.drawing2D.addDimension(drawingId, dimParam);
                         }
                     }, dim.productId);
                 },
                 addDimensions: (...dimensions) => {
-                    return this.resolve(async ([]) => {
+                    return this.resolve(async ([...rDimensions]) => {
                         const dimsToAdd = [];
-                        dimensions.forEach(dim => {
-                            const orientation = getOrientationType(dim.dimParam.dimOrientation);
-                            const view = getViewType(dim.dxfView);
+                        rDimensions.forEach(dim => {
                             const dimensionType = getDimensionType(dim.dimParam.dimType);
-                            if (orientation !== undefined && view !== undefined) {
+                            if (dim.dimParam.dimOrientation !== undefined && dim.dxfView !== undefined) {
                                 dimsToAdd.push([
                                     dim.productId,
                                     [
@@ -437,23 +328,22 @@ export default class CAD {
                                         dim.dimParam.dimEndPos,
                                         dim.dimParam.dimTextPos,
                                         dim.dimParam.dimTextAngle,
-                                        orientation,
+                                        dim.dimParam.dimOrientation,
                                         dim.dimParam.dimColor || 256,
                                         dim.dimParam.dimLayer || '2', // which layer makes sense as default?
                                     ],
-                                    view,
+                                    dim.dxfView,
                                 ]);
                             }
                         });
                         return ccAPI.drawing2D.addDimensions(drawingId, dimsToAdd);
-                    });
+                    }, ...dimensions);
                 },
                 create2DViews: (productId, viewTypes) => {
                     return this.resolve(async ([rProductId]) => {
-                        const types = viewTypes.map(viewType => getViewType(viewType));
-                        const viewIds = await ccAPI.drawing2D.create2DViews(drawingId, rProductId, types);
+                        const viewIds = await ccAPI.drawing2D.create2DViews(drawingId, rProductId, viewTypes);
                         if (viewIds !== null) {
-                            await ccAPI.drawing2D.centerAllViews(drawingId, rProductId, types);
+                            await ccAPI.drawing2D.centerAllViews(drawingId, rProductId, viewTypes);
                             return viewIds;
                         }
                         return null;
@@ -461,8 +351,7 @@ export default class CAD {
                 },
                 getBoundaryBoxFromViews: (productId, viewTypes) => {
                     return this.resolve(async ([rProductId]) => {
-                        const types = viewTypes === null || viewTypes === void 0 ? void 0 : viewTypes.map(viewType => getViewType(viewType));
-                        const bbs = await ccAPI.drawing2D.getBoundaryBoxFromViews(drawingId, rProductId, types);
+                        const bbs = await ccAPI.drawing2D.getBoundaryBoxFromViews(drawingId, rProductId, viewTypes);
                         return bbs;
                     }, productId);
                 },
@@ -470,9 +359,8 @@ export default class CAD {
                     return this.resolve(async ([rProductId]) => {
                         const viewPositionParams = [];
                         viewPositions.forEach(viewPos => {
-                            const type = getViewType(viewPos.viewType);
-                            if (type !== undefined) {
-                                viewPositionParams.push([type, viewPos.vector]);
+                            if (viewPos.viewType !== undefined) {
+                                viewPositionParams.push([viewPos.viewType, viewPos.vector]);
                             }
                         });
                         return ccAPI.drawing2D.place2DViews(drawingId, rProductId, viewPositionParams);
@@ -483,112 +371,247 @@ export default class CAD {
                         return ccAPI.drawing2D.exportDXF(drawingId, rProductId);
                     }, productId);
                 },
+                exportSVG: (productId) => {
+                    return this.resolve(async ([rProductId]) => {
+                        return ccAPI.drawing2D.exportSVG(drawingId, rProductId);
+                    }, productId);
+                },
                 removeDimensions: (dimensionIds) => {
-                    return this.resolve(async () => {
-                        return ccAPI.drawing2D.removeDimensions(drawingId, dimensionIds);
-                    });
+                    return this.resolve(async ([...rDimensionIds]) => {
+                        return 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, CCClasses.CCLinearPattern, 'LinearPattern');
+                        if (patternId != null) {
+                            // entities
+                            const cDrawing = await 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, CCClasses.CCCircularPattern, 'CircularPattern');
+                        if (patternId != null) {
+                            // entities
+                            const cDrawing = await 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 getDrawing(drawingId);
+                            const sketchLines = [];
+                            // TODO: Which sketch lines need to be included, is CCClasses.CCCurve and its derivation enough?
+                            sketchLines.push(...ccUtils.base.getChildren(rSketchId, 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 getDrawing(drawingId);
+                            const sketchLines = [];
+                            sketchLines.push(...ccUtils.base.getChildren(rSketchId, CCClasses.CCCircle, cDrawing.structure.tree));
+                            sketchLines.push(...ccUtils.base.getChildren(rSketchId, 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]) => {
+                    return this.resolve(async ([rPartId, rEntities]) => {
                         const cDrawing = await getDrawing(drawingId);
                         const entArray = [];
                         for (const rEntity of rEntities) {
-                            const entity = cDrawing.structure.tree[rEntity].children;
+                            const entity = cDrawing.structure.tree[(await rEntity)].children;
                             if (entity != undefined) {
                                 entArray.push(entity[0]);
                             }
                         }
-                        const boolType = getBoolType(type);
-                        if (boolType != undefined) {
-                            const boolId = await featureAPI.createBooleanOperation(drawingId, rPartId, {
-                                type: boolType,
-                                entities: entArray,
-                            });
-                            if (boolId != null) {
-                                await featureAPI.updateBooleanOperation(drawingId, boolId, boolType, entArray);
-                                return boolId;
-                            }
+                        const boolId = await featureAPI.createBooleanOperation(drawingId, rPartId, {
+                            type,
+                            entities: entArray,
+                        });
+                        if (boolId != null) {
+                            await featureAPI.updateBooleanOperation(drawingId, boolId, type, entArray);
+                            return boolId;
                         }
-                        return null; // Todo: Exceptions?
-                    }, partId, ...entities);
+                        return null;
+                    }, partId, entities);
                 },
                 box: (partId, references, width, length, height) => {
-                    return this.resolve(async ([rPartId]) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
                         const boxId = await featureAPI.createFeature(drawingId, rPartId, 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, references, widthParam, lengthParam, heightParam);
+                            await featureAPI.updateBox(drawingId, boxId, rReferences, widthParam, lengthParam, heightParam);
                             return boxId;
                         }
                         return null;
-                    }, partId);
+                    }, partId, ...references);
                 },
                 cylinder: (partId, references, diameter, height) => {
-                    return this.resolve(async ([rPartId]) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
                         const cylId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCCylinder, 'Cylinder');
                         if (cylId != null) {
-                            const diameterParam = { value: diameter, isExpr: typeof length === 'string' };
+                            const diameterParam = { value: diameter, isExpr: typeof diameter === 'string' };
                             const heightParam = { value: height, isExpr: typeof height === 'string' };
-                            await featureAPI.updateCylinder(drawingId, cylId, references, diameterParam, heightParam);
+                            await featureAPI.updateCylinder(drawingId, cylId, rReferences, diameterParam, heightParam);
                             return cylId;
                         }
                         return null;
-                    }, partId);
+                    }, partId, ...references);
                 },
                 chamfer: (partId, type, references, dist1, dist2, angle) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                    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, CCClasses.CCChamfer, 'Chamfer');
-                        const chamferType = getChamferType(type);
-                        if (chamferType != undefined && chamferId != null) {
-                            await featureAPI.updateChamfer(drawingId, chamferId, chamferType, rReferences, dist1Param, dist2Param, angleParam);
+                        if (chamferId != null) {
+                            await featureAPI.updateChamfer(drawingId, chamferId, type, rReferences, dist1Param, dist2Param, angleParam);
                             return chamferId;
                         }
                         return null;
-                    }, partId, ...references);
+                    }, partId, references);
                 },
                 cone: (partId, references, bDiameter, tDiameter, height) => {
-                    return this.resolve(async ([rPartId]) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
                         const coneId = await featureAPI.createFeature(drawingId, rPartId, 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, references, bDiamParam, tDiamParam, heightParam);
+                            await featureAPI.updateCone(drawingId, coneId, rReferences, bDiamParam, tDiamParam, heightParam);
                             return coneId;
                         }
                         return null;
-                    }, partId);
+                    }, partId, ...references);
                 },
                 createFastenedConstraint: (asmId, mate1, mate2, xOffset, yOffset, zOffset, name) => {
-                    return this.resolve(async ([rAsmId]) => {
+                    return this.resolve(async ([rAsmId, rMate1, rMate2, rMatePath1, rMatePath2]) => {
                         const constraintId = await ccAPI.assemblyBuilder.create3DConstraint(drawingId, rAsmId, 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 ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, constraintId, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], [mate2.matePath, mate2.wcsId, mate2.flip, mate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                            rMatePath1 = Array.isArray(rMatePath1) ? rMatePath1 : [rMatePath1];
+                            rMatePath2 = Array.isArray(rMatePath2) ? rMatePath2 : [rMatePath2];
+                            await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, constraintId, [rMatePath1, rMate1.wcsId, rMate1.flip, rMate1.reoriented], [rMatePath2, rMate2.wcsId, rMate2.flip, rMate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
                             return constraintId;
                         }
                         return null;
-                    }, asmId);
+                    }, asmId, mate1, mate2, ...mate1.matePath, ...mate2.matePath);
                 },
                 updateFastenedConstraint: (constrId, mate1, mate2, xOffset, yOffset, zOffset) => {
-                    return this.resolve(async ([rConstrId]) => {
-                        const xOffsetParam = { value: xOffset, isExpr: false };
-                        const yOffsetParam = { value: yOffset, isExpr: false };
-                        const zOffsetParam = { value: zOffset, isExpr: false };
-                        await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, rConstrId, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], [mate2.matePath, mate2.wcsId, mate2.flip, mate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
-                    }, constrId);
+                    return this.resolve(async ([rConstrId, rMate1, rMate2, rMatePath1, rMatePath2]) => {
+                        const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
+                        const yOffsetParam = { value: yOffset, isExpr: typeof xOffset === 'string' };
+                        const zOffsetParam = { value: zOffset, isExpr: typeof xOffset === 'string' };
+                        rMatePath1 = Array.isArray(rMatePath1) ? rMatePath1 : [rMatePath1];
+                        rMatePath2 = Array.isArray(rMatePath2) ? rMatePath2 : [rMatePath2];
+                        await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, rConstrId, [rMatePath1, rMate1.wcsId, rMate1.flip, rMate1.reoriented], [rMatePath2, rMate2.wcsId, rMate2.flip, rMate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                    }, constrId, mate1, mate2, ...mate1.matePath, ...mate2.matePath);
                 },
                 updateFastenedConstraints: (...constraints) => {
-                    return this.resolve(async ([]) => {
+                    return this.resolve(async ([...rConstraints]) => {
                         const constrToAdd = [];
-                        constraints.forEach(constr => {
+                        rConstraints.forEach(constr => {
                             const xOffsetParam = [constr.xOffset, typeof constr.xOffset === 'string'];
                             const yOffsetParam = [constr.yOffset, typeof constr.yOffset === 'string'];
                             const zOffsetParam = [constr.zOffset, typeof constr.zOffset === 'string'];
@@ -602,33 +625,35 @@ export default class CAD {
                             ]);
                         });
                         await ccAPI.assemblyBuilder.updateFastenedConstraints(drawingId, constrToAdd);
-                    });
+                    }, ...constraints);
                 },
                 createFastenedOriginConstraint: (asmId, mate1, xOffset, yOffset, zOffset, name) => {
-                    return this.resolve(async ([rAsmId]) => {
+                    return this.resolve(async ([rAsmId, rMatePath, rMateWcsId]) => {
                         const constraintId = await ccAPI.assemblyBuilder.create3DConstraint(drawingId, rAsmId, 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 ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, constraintId, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                            rMatePath = Array.isArray(rMatePath) ? rMatePath : [rMatePath];
+                            await ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, constraintId, [rMatePath, rMateWcsId, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
                             return constraintId;
                         }
                         return null;
-                    }, asmId);
+                    }, asmId, ...mate1.matePath, mate1.wcsId);
                 },
                 updateFastenedOriginConstraint: (constrId, mate1, xOffset, yOffset, zOffset) => {
-                    return this.resolve(async ([rConstrId]) => {
+                    return this.resolve(async ([rConstrId, rMatePath, rMateWcsId]) => {
                         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 ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, rConstrId, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
-                    }, constrId);
+                        rMatePath = Array.isArray(rMatePath) ? rMatePath : [rMatePath];
+                        await ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, rConstrId, [rMatePath, rMateWcsId, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                    }, constrId, ...mate1.matePath, mate1.wcsId);
                 },
                 updateFastenedOriginConstraints: (...constraints) => {
-                    return this.resolve(async ([]) => {
+                    return this.resolve(async ([...rConstraints]) => {
                         const constrToAdd = [];
-                        constraints.forEach(constr => {
+                        rConstraints.forEach(constr => {
                             const xOffsetParam = [constr.xOffset, typeof constr.xOffset === 'string'];
                             const yOffsetParam = [constr.yOffset, typeof constr.yOffset === 'string'];
                             const zOffsetParam = [constr.zOffset, typeof constr.zOffset === 'string'];
@@ -641,7 +666,7 @@ export default class CAD {
                             ]);
                         });
                         await ccAPI.assemblyBuilder.updateFastenedOriginConstraints(drawingId, constrToAdd);
-                    });
+                    }, ...constraints);
                 },
                 createBufferGeometry: async (objectId) => {
                     await this.queue;
@@ -673,18 +698,18 @@ export default class CAD {
                     return scene;
                 },
                 createExpressions: (partId, ...members) => {
-                    return this.resolve(async (resolvedArgs) => {
+                    return this.resolve(async ([rPartId]) => {
                         const membersToAdd = [];
                         members.forEach(mem => {
                             const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
-                            const dataType = getDataType(mem.value);
+                            const dataType = isExpr ? DataType.REAL : getDataType(mem.value); // TODO: Aktuell nur Real Werte als Expression
                             const featureAPIParam = {
                                 value: mem.value,
                                 isExpr: isExpr,
                             };
                             membersToAdd.push([mem.name, featureAPIParam, dataType]);
                         });
-                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], membersToAdd, [], []);
+                        const success = featureAPI.updateExpressionSet(drawingId, rPartId, membersToAdd, [], []);
                         return success;
                     }, partId);
                 },
@@ -711,121 +736,109 @@ export default class CAD {
                     });
                 },
                 createWorkAxis: (partId, type, references, position, direction, local, name) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const wAType = getWAType(type);
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wAName = name ? name : 'WorkAxis';
                         const wARefs = rReferences;
-                        if (wAType != undefined) {
-                            const wAId = await featureAPI.createWorkAxis(drawingId, rPartId, {
-                                axisType: wAType,
-                                references: wARefs,
-                                name: wAName,
-                                position: position,
-                                direction: direction,
-                                local: local,
-                            });
-                            if (wAId != null) {
-                                const positionParam = {
-                                    value: position,
-                                    isExpr: typeof position === 'string',
-                                };
-                                const directionParam = {
-                                    value: direction,
-                                    isExpr: typeof direction === 'string',
-                                };
-                                await featureAPI.updateWorkAxis(drawingId, wAId, wAType, wARefs, positionParam, directionParam, local);
-                                return wAId;
-                            }
+                        const wAId = await featureAPI.createWorkAxis(drawingId, rPartId, {
+                            axisType: type,
+                            references: wARefs,
+                            name: wAName,
+                            position: position,
+                            direction: direction,
+                            local: local,
+                        });
+                        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, wARefs, positionParam, directionParam, local);
+                            return wAId;
                         }
                         return null;
-                    }, partId, references);
+                    }, partId, ...references);
                 },
                 createWorkCoordSystem: (partId, type, references, coordinateSystem, offset, rotation, inverted, local, name) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const wCSType = getWCSType(type);
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wCSName = name ? name : 'WorkCoordSystem';
                         const wCSRefs = rReferences;
-                        if (wCSType != undefined) {
-                            const wCSId = await featureAPI.createWorkCoordSystem(drawingId, rPartId, {
-                                coordSystemType: wCSType,
-                                name: wCSName,
-                                references: wCSRefs,
-                                coordinateSystem,
-                                offset,
-                                rotation,
-                                inverted,
-                                local,
-                            });
-                            if (wCSId != null) {
-                                const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
-                                const rotationParam = {
-                                    value: rotation,
-                                    isExpr: typeof rotation === 'string',
-                                };
-                                await featureAPI.updateWorkCoordSystem(drawingId, wCSId, wCSType, wCSRefs, coordinateSystem, offsetParam, rotationParam, inverted, local);
-                                return wCSId;
-                            }
+                        const wCSId = await featureAPI.createWorkCoordSystem(drawingId, rPartId, {
+                            coordSystemType: type,
+                            name: wCSName,
+                            references: wCSRefs,
+                            coordinateSystem,
+                            offset,
+                            rotation,
+                            inverted,
+                            local,
+                        });
+                        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, wCSRefs, coordinateSystem, offsetParam, rotationParam, inverted, local);
+                            return wCSId;
                         }
                         return null;
-                    }, partId, references);
+                    }, partId, ...references);
                 },
                 createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const wPType = getWPType(type);
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wPName = name ? name : 'WorkPlane';
                         const wPRefs = rReferences;
-                        if (wPType != undefined) {
-                            const wPId = await featureAPI.createWorkPlane(drawingId, rPartId, {
-                                planeType: wPType,
-                                references: wPRefs,
-                                offsetOrAngle: offset,
-                                name: wPName,
-                                position: position,
-                                normal: normal,
-                                local: local,
-                            });
-                            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, wPType, wPRefs, offsetParam, angleParam, positionParam, normalParam, local);
-                                return wPId;
-                            }
+                        const wPId = await featureAPI.createWorkPlane(drawingId, rPartId, {
+                            planeType: type,
+                            references: wPRefs,
+                            offsetOrAngle: offset,
+                            name: wPName,
+                            position: position,
+                            normal: normal,
+                            local: local,
+                        });
+                        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, wPRefs, offsetParam, angleParam, positionParam, normalParam, local);
+                            return wPId;
                         }
                         return null;
-                    }, partId, references);
+                    }, partId, ...references);
                 },
                 createWorkPoint: (partId, type, references, position, local, name) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const wPTType = getWPTType(type);
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wPTName = name ? name : 'WorkPoint';
                         const wPTRefs = rReferences;
-                        if (wPTType != undefined) {
-                            const wPTId = await featureAPI.createWorkPoint(drawingId, rPartId, {
-                                pointType: wPTType,
-                                references: wPTRefs,
-                                name: wPTName,
-                                position: position,
-                                local: local,
-                            });
-                            if (wPTId != undefined) {
-                                const positionParam = {
-                                    value: position,
-                                    isExpr: typeof position === 'string',
-                                };
-                                await featureAPI.updateWorkPoint(drawingId, wPTId, wPTType, wPTRefs, positionParam, local);
-                                return wPTId;
-                            }
+                        const wPTId = await featureAPI.createWorkPoint(drawingId, rPartId, {
+                            pointType: type,
+                            references: wPTRefs,
+                            name: wPTName,
+                            position: position,
+                            local: local,
+                        });
+                        if (wPTId != undefined) {
+                            const positionParam = {
+                                value: position,
+                                isExpr: typeof position === 'string',
+                            };
+                            await featureAPI.updateWorkPoint(drawingId, wPTId, type, wPTRefs, positionParam, local);
+                            return wPTId;
                         }
                         return null;
-                    }, partId, references);
+                    }, partId, ...references);
                 },
                 fillet: (partId, references, radius) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                    return this.resolve(async ([rPartId, rReferences]) => {
                         const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
                         const filletId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCConstantRadiusFillet, 'Fillet');
                         if (filletId != null) {
@@ -833,7 +846,39 @@ export default class CAD {
                             return filletId;
                         }
                         return null;
-                    }, partId, ...references);
+                    }, partId, references);
+                },
+                findOrSelect: (partId, type, length, positions) => {
+                    return this.resolve(async ([rPartId]) => {
+                        let filter = lineSegmentsFilter;
+                        switch (type) {
+                            case 0: // Vertex
+                                filter = pointFilter;
+                                break;
+                            case 1: // Edge
+                                filter = lineSegmentsFilter;
+                                break;
+                            case 2: // Loop
+                                filter = loopFilter;
+                                break;
+                            case 3: // Face
+                                filter = planeFilter;
+                                break;
+                        }
+                        const geometries = positions
+                            ? await ccAPI.geometry.findGeometriesByPoints(drawingId, rPartId, type, positions)
+                            : await waitForSelect(length, filter, (resolveSelection, items, diff) => {
+                                if (items.length > length - 1) {
+                                    resolveSelection(items.map(i => i.data.graphicId));
+                                    ccAPI.geometry
+                                        .getPointsByGeometries(drawingId, items.map(i => i.data.graphicId))
+                                        .then(points => {
+                                        logPoints(points);
+                                    });
+                                }
+                            });
+                        return geometries;
+                    }, partId);
                 },
                 getAssemblyFromContainer: (asmName) => {
                     return this.resolve(async ([]) => {
@@ -913,9 +958,9 @@ export default class CAD {
                 },
                 getFeatureByName: (partId, featureName) => {
                     return this.resolve(async ([rProductId]) => {
-                        const solid = await featureAPI.getFeatureByName(drawingId, rProductId, featureName);
-                        if (solid !== null) {
-                            return solid;
+                        const feature = await featureAPI.getFeatureByName(drawingId, rProductId, featureName);
+                        if (feature !== null) {
+                            return feature;
                         }
                         return null;
                     }, partId);
@@ -926,13 +971,13 @@ export default class CAD {
                     }, referenceId, ownerId);
                 },
                 removeNodes: (...nodes) => {
-                    return this.resolve(async ([]) => {
+                    return this.resolve(async ([...rNodes]) => {
                         const nodesToRemove = [];
-                        nodes.forEach(node => {
+                        rNodes.forEach(node => {
                             nodesToRemove.push([node.referenceId, node.ownerId]);
                         });
                         return ccAPI.assemblyBuilder.removeNodes(drawingId, nodesToRemove);
-                    });
+                    }, ...nodes);
                 },
                 importFeature: (partId, content, format, name) => {
                     return this.resolve(async ([rPartId]) => {
@@ -947,19 +992,58 @@ export default class CAD {
                         return null;
                     }, partId);
                 },
+                loadSketch: (partId, stream, planeId, name) => {
+                    return this.resolve(async ([rPartId, rPlaneId]) => {
+                        const sketch = await sketcherAPI.createSketch(drawingId, rPartId);
+                        if (sketch) {
+                            const tree = getDrawing(drawingId).structure.tree;
+                            const plane = tree[rPlaneId];
+                            if (plane && base.isA(plane.class, 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) {
+                            const tree = getDrawing(drawingId).structure.tree;
+                            const plane = tree[rPlaneId];
+                            if (plane && base.isA(plane.class, 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 ccAPI.assemblyBuilder.setNodeTransformation(drawingId, rRefId, rOwnerId, transformation);
                     }, referenceId, ownerId);
                 },
                 translate: (partId, featureIds, references, inverted, distance) => {
-                    return this.resolve(async ([rPartId, rFeatureIds, rReferences]) => {
+                    return this.resolve(async ([rPartId, rFeatureIds, ...rReferences]) => {
                         const translationId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCTranslation, 'Translate');
                         if (translationId !== null) {
                             const cDrawing = await getDrawing(drawingId);
                             const entArray = [];
                             for (const rFeatureId of rFeatureIds) {
-                                const entity = cDrawing.structure.tree[rFeatureId].children;
+                                const entity = cDrawing.structure.tree[(await rFeatureId)].children;
                                 if (entity != undefined) {
                                     entArray.push(entity[0]);
                                 }
@@ -969,8 +1053,9 @@ export default class CAD {
                             return translationId;
                         }
                         return null;
-                    }, partId, featureIds, references);
+                    }, partId, featureIds, ...references);
                 },
+                // TODO: Remove this method. Is it necessary?
                 updateTranslate: (translationId, distance) => {
                     return this.resolve(async ([rTranslationId]) => {
                         const cDrawing = await getDrawing(drawingId);
@@ -990,12 +1075,21 @@ export default class CAD {
                 save: (type) => {
                     return ccAPI.baseModeler.save(drawingId, type);
                 },
+                saveToUrl: (url, filetype) => {
+                    return ccAPI.baseModeler.saveToUrl(drawingId, url, filetype);
+                },
                 load: (content, type) => {
                     return ccAPI.baseModeler.load(drawingId, content, type);
                 },
+                loadFromUrl: (url, filetype) => {
+                    return ccAPI.baseModeler.loadFromUrl(drawingId, url, filetype, true);
+                },
                 loadProduct: (content, type) => {
                     return ccAPI.assemblyBuilder.loadProduct(drawingId, content, type);
                 },
+                loadProductFromUrl: (url, filetype) => {
+                    return ccAPI.assemblyBuilder.loadProductFromUrl(drawingId, url, filetype);
+                },
                 pick: (partId, type, points) => {
                     return this.resolve(async ([rPartId]) => {
                         const refs = await featureAPI.pick(drawingId, rPartId, type, points);
@@ -1006,7 +1100,7 @@ export default class CAD {
                     }, partId);
                 },
                 setExpressions: (partId, ...members) => {
-                    return this.resolve(async (resolvedArgs) => {
+                    return this.resolve(async ([rPartId]) => {
                         const membersToModify = [];
                         members.forEach(mem => {
                             const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
@@ -1016,16 +1110,16 @@ export default class CAD {
                             };
                             membersToModify.push([mem.name, featureAPIParam]);
                         });
-                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], [], membersToModify, []);
+                        const success = featureAPI.updateExpressionSet(drawingId, rPartId, [], membersToModify, []);
                         return success;
                     }, partId);
                 },
                 setExpressionSets: (...exprSets) => {
-                    return this.resolve(async ([]) => {
+                    return this.resolve(async ([...rExprSets]) => {
                         const exprSetsToSet = [];
-                        exprSets.forEach(exprSet => {
+                        rExprSets.forEach(exprSet => {
                             const membersToModify = [];
-                            exprSet.members.forEach(mem => {
+                            exprSet.members.forEach((mem) => {
                                 const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
                                 membersToModify.push([mem.name, [mem.value, isExpr]]);
                             });
@@ -1033,24 +1127,24 @@ export default class CAD {
                         });
                         const success = await featureAPI.updateExpressionSets(drawingId, exprSetsToSet);
                         return success;
-                    });
+                    }, ...exprSets);
                 },
                 deleteExpressions: (partId, members) => {
-                    return this.resolve(async (resolvedArgs) => {
-                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], [], [], 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]) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
                         const sphereId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCSphere, 'Sphere');
                         if (sphereId != null) {
                             const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
-                            await featureAPI.updateSphere(drawingId, sphereId, references, radiusParam);
+                            await featureAPI.updateSphere(drawingId, sphereId, rReferences, radiusParam);
                             return sphereId;
                         }
                         return null;
-                    }, partId);
+                    }, partId, ...references);
                 },
             };
             callback(publicApi);