@buerli.io/headless 0.0.33 → 0.0.35-beta.0

package/build/cjs/history.js

@@ -0,0 +1,814 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+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 featureAPI = classcad_1.ccAPI.feature;
+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 classcad_1.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 = core_1.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);
+        }
+    }
+};
+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;
+    }
+};
+const getBoolType = (type) => {
+    switch (type) {
+        case 'Union':
+            return classcad_1.BooleanOperationType.UNION;
+        case 'Subtraction':
+            return classcad_1.BooleanOperationType.SUBTRACTION;
+        case 'Intersection':
+            return classcad_1.BooleanOperationType.INTERSECTION;
+        case undefined:
+            break;
+    }
+};
+const getChamferType = (type) => {
+    switch (type) {
+        case 'Equal_Distance':
+            return classcad_1.ChamferType.EQUAL_DISTANCE;
+        case 'Two_Distances':
+            return classcad_1.ChamferType.TWO_DISTANCES;
+        case 'Distance_And_Angle':
+            return classcad_1.ChamferType.DISTANCE_AND_ANGLE;
+        case undefined:
+            break;
+    }
+};
+const getWCSType = (type) => {
+    switch (type) {
+        case 'XYAxisOrigin':
+            return classcad_1.WorkCoordSystemType.WCS_XYAXISORIGIN;
+        case 'Custom':
+            return classcad_1.WorkCoordSystemType.WCS_CUSTOM;
+        case undefined:
+            break;
+    }
+};
+const getWAType = (type) => {
+    switch (type) {
+        case 'Custom':
+            return classcad_1.WorkAxisType.WA_USERDEFINED;
+        case 'WorkPoints':
+            return classcad_1.WorkAxisType.WA_WORKPOINTS;
+        case 'PointAndDirection':
+            return classcad_1.WorkAxisType.WA_POINTDIRECTION;
+        case 'SketchLine':
+            return classcad_1.WorkAxisType.WA_SKETCHLINE;
+        case 'Curve':
+            return classcad_1.WorkAxisType.WA_CURVE;
+        case '2Points':
+            return classcad_1.WorkAxisType.WA_2POINTS;
+        case '2Planes':
+            return classcad_1.WorkAxisType.WA_2PLANES;
+        case undefined:
+            break;
+    }
+};
+const getWPType = (type) => {
+    switch (type) {
+        case 'Custom':
+            return classcad_1.WorkPlaneType.WP_USERDEFINED;
+        case 'Plane':
+            return classcad_1.WorkPlaneType.WP_PLANE;
+        case 'EdgeAndPoint':
+            return classcad_1.WorkPlaneType.WP_EDGEPOINT;
+        case '3Points':
+            return classcad_1.WorkPlaneType.WP_3POINTS;
+        case 'PointAndNormal':
+            return classcad_1.WorkPlaneType.WP_POINTNORMAL;
+        case 'PointAndFace':
+            return classcad_1.WorkPlaneType.WP_POINTFACE;
+        case 'LinePlaneAndAngle':
+            return classcad_1.WorkPlaneType.WP_LINEPLANEANGLE;
+        case undefined:
+            break;
+    }
+};
+const getWPTType = (type) => {
+    switch (type) {
+        case 'Custom':
+            return classcad_1.WorkPointType.WPT_USERDEFINED;
+        case 'Point':
+            return classcad_1.WorkPointType.WPT_BREPVERTEX;
+        case 'MidPointLine':
+            return classcad_1.WorkPointType.WPT_EDGEMIDPOINT;
+        case 'Center':
+            return classcad_1.WorkPointType.WPT_CENTER;
+        case 'BaryCenter':
+            return classcad_1.WorkPointType.WPT_BARYCENTER;
+        case 'Intersection':
+            return classcad_1.WorkPointType.WPT_INTERSECTION;
+        case 'InnerCircle':
+            return classcad_1.WorkPointType.WPT_INNERCIRCLE;
+        case 'MidPointOf2Points':
+            return classcad_1.WorkPointType.WPT_2POINTS;
+        case undefined:
+            break;
+    }
+};
+const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray) => {
+    let cDrawing = 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 = 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);
+            }
+        }
+    }
+};
+const createRecursiveScene = async (object, drawingId, root, options) => {
+    let cDrawing = 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 = [];
+            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 = core_1.getDrawing(drawingId); // get current drawing state after request
+                    cachedSolid = cDrawing.geometry.cache[solid];
+                }
+                if (cachedSolid)
+                    meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
+            }
+            if (meshes.length > 0) {
+                if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+                    const part = new three_1.Group();
+                    part.matrix = core_1.MathUtils.convertToMatrix4(object.coordinateSystem);
+                    part.matrixAutoUpdate = false;
+                    part.userData = { id: object.id };
+                    part.name = object.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 {
+                    const mesh = new three_1.Mesh();
+                    mesh.matrix = core_1.MathUtils.convertToMatrix4(object.coordinateSystem);
+                    mesh.matrixAutoUpdate = false;
+                    mesh.userData = { id: object.id };
+                    mesh.name = object.name;
+                    mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(meshes.map(m => m.geometry));
+                    mesh.material = new three_1.MeshStandardMaterial();
+                    root.add(mesh);
+                }
+            }
+        }
+    }
+    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.name = object.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);
+            }
+        }
+    }
+};
+class CAD {
+    constructor(url) {
+        this.drawingId = null;
+        this.queue = Promise.resolve(0);
+        this.queue = Promise.resolve(0);
+        core_1.init({ url });
+    }
+    resolve(callback, ...args) {
+        // eslint-disable-next-line promise/no-callback-in-promise
+        return (this.queue = this.queue.then(() => Promise.all(args).then(callback)));
+    }
+    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]) => {
+                        return classcad_1.ccAPI.assemblyBuilder.addNode(drawingId, rProductId, rOwnerId, transformation, name);
+                    }, productId, ownerId);
+                },
+                addNodes: (...nodes) => {
+                    return this.resolve(async ([]) => {
+                        const nodesToAdd = [];
+                        nodes.forEach(node => {
+                            nodesToAdd.push([node.productId, node.ownerId, node.transformation, node.name]);
+                        });
+                        return classcad_1.ccAPI.assemblyBuilder.addNodes(drawingId, nodesToAdd);
+                    });
+                },
+                boolean: (partId, type, entities) => {
+                    return this.resolve(async ([rPartId, ...rEntities]) => {
+                        const cDrawing = await core_1.getDrawing(drawingId);
+                        const entArray = [];
+                        for (const rEntity of rEntities) {
+                            const entity = cDrawing.structure.tree[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;
+                            }
+                        }
+                        return null; // Todo: Exceptions?
+                    }, partId, ...entities);
+                },
+                box: (partId, references, width, length, height) => {
+                    return this.resolve(async ([rPartId]) => {
+                        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, references, widthParam, lengthParam, heightParam);
+                            return boxId;
+                        }
+                        return null;
+                    }, partId);
+                },
+                cylinder: (partId, references, diameter, height) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const cylId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCCylinder, 'Cylinder');
+                        if (cylId != null) {
+                            const diameterParam = { value: diameter, isExpr: typeof length === 'string' };
+                            const heightParam = { value: height, isExpr: typeof height === 'string' };
+                            await featureAPI.updateCylinder(drawingId, cylId, references, diameterParam, heightParam);
+                            return cylId;
+                        }
+                        return null;
+                    }, partId);
+                },
+                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');
+                        const chamferType = getChamferType(type);
+                        if (chamferType != undefined && chamferId != null) {
+                            await featureAPI.updateChamfer(drawingId, chamferId, chamferType, rReferences, dist1Param, dist2Param, angleParam);
+                            return chamferId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                cone: (partId, references, bDiameter, tDiameter, height) => {
+                    return this.resolve(async ([rPartId]) => {
+                        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, references, bDiamParam, tDiamParam, heightParam);
+                            return coneId;
+                        }
+                        return null;
+                    }, partId);
+                },
+                createFastenedConstraint: (asmId, mate1, mate2, xOffset, yOffset, zOffset, name) => {
+                    return this.resolve(async ([rAsmId]) => {
+                        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, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], [mate2.matePath, mate2.wcsId, mate2.flip, mate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                            return constraintId;
+                        }
+                        return null;
+                    }, asmId);
+                },
+                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 classcad_1.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);
+                },
+                updateFastenedConstraints: (...constraints) => {
+                    return this.resolve(async ([]) => {
+                        const constrToAdd = [];
+                        constraints.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'];
+                            constrToAdd.push([constr.constrId,
+                                [constr.mate1.matePath, constr.mate1.wcsId, constr.mate1.flip, constr.mate1.reoriented],
+                                [constr.mate2.matePath, constr.mate2.wcsId, constr.mate2.flip, constr.mate2.reoriented],
+                                xOffsetParam, yOffsetParam, zOffsetParam]);
+                        });
+                        await classcad_1.ccAPI.assemblyBuilder.updateFastenedConstraints(drawingId, constrToAdd);
+                    });
+                },
+                createFastenedOriginConstraint: (asmId, mate1, xOffset, yOffset, zOffset, name) => {
+                    return this.resolve(async ([rAsmId]) => {
+                        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, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                            return constraintId;
+                        }
+                        return null;
+                    }, asmId);
+                },
+                updateFastenedOriginConstraint: (constrId, mate1, xOffset, yOffset, zOffset) => {
+                    return this.resolve(async ([rConstrId]) => {
+                        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, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                    }, constrId);
+                },
+                updateFastenedOriginConstraints: (...constraints) => {
+                    return this.resolve(async ([]) => {
+                        const constrToAdd = [];
+                        constraints.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'];
+                            constrToAdd.push([constr.constrId,
+                                [constr.mate1.matePath, constr.mate1.wcsId, constr.mate1.flip, constr.mate1.reoriented],
+                                xOffsetParam, yOffsetParam, zOffsetParam]);
+                        });
+                        await classcad_1.ccAPI.assemblyBuilder.updateFastenedOriginConstraints(drawingId, constrToAdd);
+                    });
+                },
+                createBufferGeometry: async (objectId) => {
+                    await this.queue;
+                    this.queue = Promise.resolve(0);
+                    const rObjectId = await objectId;
+                    const cDrawing = 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 = core_1.getDrawing(drawingId);
+                    const structureTree = cDrawing.structure.tree;
+                    const scene = new three_1.Scene();
+                    if (rObjectId != null) {
+                        const rootObj = structureTree[rObjectId];
+                        await createRecursiveScene(rootObj, drawingId, scene, options);
+                    }
+                    return scene;
+                },
+                createExpressions: (partId, ...members) => {
+                    return this.resolve(async (resolvedArgs) => {
+                        const membersToAdd = [];
+                        members.forEach(mem => {
+                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
+                            const dataType = getDataType(mem.value);
+                            const featureAPIParam = {
+                                value: mem.value,
+                                isExpr: isExpr,
+                            };
+                            membersToAdd.push([mem.name, featureAPIParam, dataType]);
+                        });
+                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], 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 wAType = getWAType(type);
+                        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;
+                            }
+                        }
+                        return null;
+                    }, partId, references);
+                },
+                createWorkCoordSystem: (partId, type, references, coordinateSystem, offset, rotation, inverted, local, name) => {
+                    return this.resolve(async ([rPartId, rReferences]) => {
+                        const wCSType = getWCSType(type);
+                        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;
+                            }
+                        }
+                        return null;
+                    }, partId, references);
+                },
+                createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
+                    return this.resolve(async ([rPartId, rReferences]) => {
+                        const wPType = getWPType(type);
+                        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;
+                            }
+                        }
+                        return null;
+                    }, partId, references);
+                },
+                createWorkPoint: (partId, type, references, position, local, name) => {
+                    return this.resolve(async ([rPartId, rReferences]) => {
+                        const wPTType = getWPTType(type);
+                        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;
+                            }
+                        }
+                        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);
+                },
+                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);
+                },
+                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 solid = await featureAPI.getFeatureByName(drawingId, rProductId, featureName);
+                        if (solid !== null) {
+                            return solid;
+                        }
+                        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 ([]) => {
+                        const nodesToRemove = [];
+                        nodes.forEach(node => {
+                            nodesToRemove.push([node.referenceId, node.ownerId]);
+                        });
+                        return classcad_1.ccAPI.assemblyBuilder.removeNodes(drawingId, nodesToRemove);
+                    });
+                },
+                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.loadGeometryStreamToImportFeature(drawingId, importFeatureId, content, format);
+                            if (solids !== null) {
+                                return importFeatureId;
+                            }
+                        }
+                        return null;
+                    }, partId);
+                },
+                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 core_1.getDrawing(drawingId);
+                            const entArray = [];
+                            for (const rFeatureId of rFeatureIds) {
+                                const entity = cDrawing.structure.tree[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);
+                },
+                updateTranslate: (translationId, distance) => {
+                    return this.resolve(async ([rTranslationId]) => {
+                        const cDrawing = await 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);
+                },
+                load: (content, type) => {
+                    return classcad_1.ccAPI.baseModeler.load(drawingId, content, type);
+                },
+                loadProduct: (content, type) => {
+                    return classcad_1.ccAPI.assemblyBuilder.loadProduct(drawingId, content, type);
+                },
+                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 (resolvedArgs) => {
+                        const membersToModify = [];
+                        members.forEach(mem => {
+                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
+                            const featureAPIParam = {
+                                value: mem.value,
+                                isExpr: isExpr,
+                            };
+                            membersToModify.push([mem.name, featureAPIParam]);
+                        });
+                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], [], membersToModify, []);
+                        return success;
+                    }, partId);
+                },
+                deleteExpressions: (partId, members) => {
+                    return this.resolve(async (resolvedArgs) => {
+                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], [], [], members);
+                        return success;
+                    }, partId);
+                },
+                sphere: (partId, references, radius) => {
+                    return this.resolve(async ([rPartId]) => {
+                        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, references, radiusParam);
+                            return sphereId;
+                        }
+                        return null;
+                    }, partId);
+                },
+            };
+            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;