@buerli.io/headless 0.7.1 → 0.9.0-beta.1

package/build/cjs/history.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -34,7 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 three_stdlib_1 = require("three-stdlib");
 const selection_1 = require("./utils/selection");
 const meshes_1 = require("./utils/meshes");
 const featureAPI = classcad_1.ccAPI.feature;
@@ -46,16 +23,6 @@ const geometryAPI = classcad_1.ccAPI.geometry;
 const baseUtils = classcad_1.ccUtils.base;
 const asmUtils = classcad_1.ccUtils.assembly;
 const partUtils = classcad_1.ccUtils.part;
-let BufferGeometryUtils = BufferGeometryUtils_;
-if (BufferGeometryUtils.BufferGeometryUtils) {
-    BufferGeometryUtils = BufferGeometryUtils.BufferGeometryUtils;
-}
-const resolveVec = (value) => {
-    if (Array.isArray(value))
-        return { x: value[0], y: value[1], z: value[2] };
-    else
-        return value;
-};
 /**
  * Returns the cclass of the given dimension type
  * @param type type of the dimension as string
@@ -104,7 +71,7 @@ const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray)
             }
             if (geometries.length > 0) {
                 const transformation = cDrawing.api.structure.calculateGlobalTransformation(object.id);
-                const bufferGeom = BufferGeometryUtils.mergeBufferGeometries(geometries);
+                const bufferGeom = (0, three_stdlib_1.mergeBufferGeometries)(geometries);
                 bufferGeom.applyMatrix4(transformation);
                 bufferGeomArray.push(bufferGeom);
             }
@@ -141,8 +108,8 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
             const matrix = object.coordinateSystem ? core_1.MathUtils.convertToMatrix4(object.coordinateSystem) : new three_1.Matrix4();
             matrix.decompose(part.position, part.quaternion, part.scale);
             part.updateMatrix();
-            part.userData = { id: object.id }; // product reference id
-            part.name = object.name; // product reference name
+            part.userData = { id: object.id }; // instance id
+            part.name = object.name; // instance name
             for (const entity of entities) {
                 let cachedEntity = cDrawing.geometry.cache[entity];
                 if (!cachedEntity) {
@@ -190,7 +157,7 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
                                     mesh.name = solidObject.name + '_' + i;
                                     mesh.userData = { id: solidObject.id }; // add solid id to the userData
                                     if (!(options === null || options === void 0 ? void 0 : options.structureOnly)) {
-                                        mesh.geometry = (BufferGeometryUtils.mergeBufferGeometries || BufferGeometryUtils.mergeGeometries)(colorMeshesMap[key].meshes.map(m => m.geometry));
+                                        mesh.geometry = (0, three_stdlib_1.mergeBufferGeometries)(colorMeshesMap[key].meshes.map(m => m.geometry));
                                         mesh.material = new three_1.MeshStandardMaterial({
                                             color: colorMeshesMap[key].color,
                                             transparent: colorMeshesMap[key].opacity < 1,
@@ -212,7 +179,7 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
                                 mesh.name = solidObject.name;
                                 mesh.userData = { id: solidObject.id }; // add solid id to the userData
                                 if (!(options === null || options === void 0 ? void 0 : options.structureOnly)) {
-                                    mesh.geometry = (BufferGeometryUtils.mergeBufferGeometries || BufferGeometryUtils.mergeGeometries)(colorMeshesMap[key].meshes.map(m => m.geometry));
+                                    mesh.geometry = (0, three_stdlib_1.mergeBufferGeometries)(colorMeshesMap[key].meshes.map(m => m.geometry));
                                     mesh.material = new three_1.MeshStandardMaterial({
                                         color: colorMeshesMap[key].color,
                                         transparent: colorMeshesMap[key].opacity < 1,
@@ -238,8 +205,8 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
         const matrix = object.coordinateSystem ? core_1.MathUtils.convertToMatrix4(object.coordinateSystem) : new three_1.Matrix4();
         matrix.decompose(assembly.position, assembly.quaternion, assembly.scale);
         assembly.updateMatrix();
-        assembly.userData = { id: object.id }; // assembly root or product reference id
-        assembly.name = object.name; // assembly root or product reference name
+        assembly.userData = { id: object.id }; // assembly root or instance id
+        assembly.name = object.name; // assembly root or instance name
         result.nodes[assembly.name] = assembly;
         root.add(assembly);
         for (const child of object.children) {
@@ -249,28 +216,11 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
         }
     }
 };
-/**
- * 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 point = resolveVec(points[i][j]);
-                const x = Math.round(point.x * 1000) / 1000;
-                const y = Math.round(point.y * 1000) / 1000;
-                const z = Math.round(point.z * 1000) / 1000;
-                log += '{ x: ' + x + ', y: ' + y + ', z: ' + z + '}';
-                log += points[i].length - 1 === j ? '' : ',';
-            }
-            log += points.length - 1 === i ? ']]' : '],[';
-        }
-        console.info(log);
-    }
+const resolveVec = (value) => {
+    if (Array.isArray(value))
+        return { x: value[0], y: value[1], z: value[2] };
+    else
+        return value;
 };
 class CAD {
     constructor() {
@@ -292,31 +242,31 @@ class CAD {
                 throw new Error('Drawing could not be created');
             this.drawingId = drawingId;
             const publicApi = {
-                addNodes: async (...nodes) => {
+                addInstances: async (...instances) => {
                     var e_1, _a;
-                    const nodesToAdd = [];
+                    const instancesToAdd = [];
                     try {
-                        for (var nodes_1 = __asyncValues(nodes), nodes_1_1; nodes_1_1 = await nodes_1.next(), !nodes_1_1.done;) {
-                            const node = nodes_1_1.value;
-                            const [rProductId, rOwnerId] = await new Promise(res => this.resolve(id => res(id), node.productId, node.ownerId));
-                            const nodeParam = {
-                                referenceId: rProductId,
+                        for (var instances_1 = __asyncValues(instances), instances_1_1; instances_1_1 = await instances_1.next(), !instances_1_1.done;) {
+                            const instance = instances_1_1.value;
+                            const [rProductId, rOwnerId] = await new Promise(res => this.resolve(id => res(id), instance.productId, instance.ownerId));
+                            const instanceParam = {
+                                productId: rProductId,
                                 ownerId: rOwnerId,
-                                transformation: node.transformation,
-                                name: node.name,
-                                options: Object.assign(Object.assign({}, node.options), { isLocal: true }), // in non-interactive mode, the transformation is local to the owner
+                                transformation: instance.transformation,
+                                name: instance.name,
+                                options: Object.assign(Object.assign({}, instance.options), { isLocal: true }), // in non-interactive mode, the transformation is local to the owner
                             };
-                            nodesToAdd.push(nodeParam);
+                            instancesToAdd.push(instanceParam);
                         }
                     }
                     catch (e_1_1) { e_1 = { error: e_1_1 }; }
                     finally {
                         try {
-                            if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) await _a.call(nodes_1);
+                            if (instances_1_1 && !instances_1_1.done && (_a = instances_1.return)) await _a.call(instances_1);
                         }
                         finally { if (e_1) throw e_1.error; }
                     }
-                    return assemblyBuilderAPI.addNodes(drawingId, nodesToAdd);
+                    return assemblyBuilderAPI.addInstances(drawingId, instancesToAdd);
                 },
                 addDimensions: async (...dimensions) => {
                     var e_2, _a;
@@ -396,17 +346,17 @@ class CAD {
                         return drawing2DAPI.removeDimensions(drawingId, rDimensionIds);
                     }, ...dimensionIds);
                 },
-                linearPattern: (partId, entities, references1, params1, references2, params2) => {
-                    return this.resolve(async ([rPartId, rEntities, rReferences1, rReferences2]) => {
+                linearPattern: (partId, operations, references1, params1, references2, params2) => {
+                    return this.resolve(async ([rPartId, rOperations, rReferences1, rReferences2]) => {
                         const patternId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCLinearPattern, 'LinearPattern');
                         if (patternId != null) {
                             // entities
                             const cDrawing = await (0, core_1.getDrawing)(drawingId);
                             const entArray = [];
-                            for (const rEntity of rEntities) {
-                                const entity = cDrawing.structure.tree[(await rEntity)].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
                                 }
                             }
                             const distance1Param = {
@@ -454,19 +404,19 @@ class CAD {
                             return patternId;
                         }
                         return null;
-                    }, partId, entities, references1, references2);
+                    }, partId, operations, references1, references2);
                 },
-                circularPattern: (partId, entities, references, params) => {
-                    return this.resolve(async ([rPartId, rEntities, ...rReferences]) => {
+                circularPattern: (partId, operations, references, params) => {
+                    return this.resolve(async ([rPartId, rOperations, ...rReferences]) => {
                         const patternId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCCircularPattern, 'CircularPattern');
                         if (patternId != null) {
                             // entities
                             const cDrawing = await (0, core_1.getDrawing)(drawingId);
                             const entArray = [];
-                            for (const rEntity of rEntities) {
-                                const entity = cDrawing.structure.tree[(await rEntity)].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
                                 }
                             }
                             const angleParam = { value: params.angle, isExpr: typeof params.angle === 'string' };
@@ -482,11 +432,11 @@ class CAD {
                             return patternId;
                         }
                         return null;
-                    }, partId, entities, ...references);
+                    }, partId, operations, ...references);
                 },
                 extrusion: (partId, sketchOrRegionIds, type, limit1, limit2, taperAngle, direction, capEnds) => {
                     return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
-                        const extrusion = await featureAPI.createExtrusion(drawingId, rPartId);
+                        const extrusion = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCExtrusion, 'Extrusion');
                         if (extrusion) {
                             const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
                             if (sketchLines) {
@@ -508,7 +458,7 @@ class CAD {
                 },
                 revolve: (partId, sketchOrRegionIds, axisIds, angle1, angle2, inverted) => {
                     return this.resolve(async ([rPartId, rSketchOrRegionIds, ...rAxisIds]) => {
-                        const revolve = await featureAPI.createRevolve(drawingId, rPartId);
+                        const revolve = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCRevolve, 'Revolve');
                         if (revolve) {
                             const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
                             if (sketchLines) {
@@ -520,26 +470,23 @@ class CAD {
                         }
                     }, partId, sketchOrRegionIds, ...axisIds);
                 },
-                boolean: (partId, type, entities) => {
-                    return this.resolve(async ([rPartId, rEntities]) => {
+                boolean: (partId, type, operations) => {
+                    return this.resolve(async ([rPartId, rOperations]) => {
                         const cDrawing = await (0, core_1.getDrawing)(drawingId);
                         const entArray = [];
-                        for (const rEntity of rEntities) {
-                            const entity = cDrawing.structure.tree[(await rEntity)].children;
-                            if (entity != undefined) {
-                                entArray.push(entity[0]);
+                        for (const rOperation of rOperations) {
+                            const entities = cDrawing.structure.tree[(await rOperation)].children;
+                            if (entities != undefined) {
+                                entArray.push(entities[0]);
                             }
                         }
-                        const boolId = await featureAPI.createBooleanOperation(drawingId, rPartId, {
-                            type,
-                            entities: entArray,
-                        });
+                        const boolId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCUnion, 'Union');
                         if (boolId != null) {
                             await featureAPI.updateBooleanOperation(drawingId, boolId, type, entArray);
                             return boolId;
                         }
                         return null;
-                    }, partId, entities);
+                    }, partId, operations);
                 },
                 box: (partId, references, width, length, height) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
@@ -592,11 +539,11 @@ class CAD {
                         return null;
                     }, partId, ...references);
                 },
-                createFastenedConstraint: async (asmId, mate1, mate2, xOffset, yOffset, zOffset, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createFastenedConstraint: async (id, mate1, mate2, xOffset, yOffset, zOffset, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCFastenedConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, classcad_1.CCClasses.CCFastenedConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -656,10 +603,10 @@ class CAD {
                     }
                     await assemblyBuilderAPI.updateFastenedConstraints(drawingId, constrToAdd);
                 },
-                createFastenedOriginConstraint: async (asmId, mate1, xOffset, yOffset, zOffset, name) => {
-                    const [rAsmId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId));
+                createFastenedOriginConstraint: async (id, mate1, xOffset, yOffset, zOffset, name) => {
+                    const [rId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId));
                     const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCFastenedOriginConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, classcad_1.CCClasses.CCFastenedOriginConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -711,11 +658,11 @@ class CAD {
                     }
                     await assemblyBuilderAPI.updateFastenedOriginConstraints(drawingId, constraintsToAdd);
                 },
-                createCylindricalConstraint: async (asmId, mate1, mate2, zOffsetLimits, zRotationLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createCylindricalConstraint: async (id, mate1, mate2, zOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCCylindricalConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, classcad_1.CCClasses.CCCylindricalConstraint, name);
                     if (constraintId != null) {
                         await assemblyBuilderAPI.updateCylindricalConstraints(drawingId, [
                             {
@@ -777,11 +724,11 @@ class CAD {
                     }
                     await assemblyBuilderAPI.updateCylindricalConstraints(drawingId, constrToAdd);
                 },
-                createRevoluteConstraint: async (asmId, mate1, mate2, zOffset, zRotationLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createRevoluteConstraint: async (id, mate1, mate2, zOffset, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCRevoluteConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, classcad_1.CCClasses.CCRevoluteConstraint, name);
                     if (constraintId != null) {
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
                         await assemblyBuilderAPI.updateRevoluteConstraints(drawingId, [
@@ -845,11 +792,11 @@ class CAD {
                     }
                     await assemblyBuilderAPI.updateRevoluteConstraints(drawingId, constrToAdd);
                 },
-                createSliderConstraint: async (asmId, mate1, mate2, xOffset, yOffset, zOffsetLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createSliderConstraint: async (id, mate1, mate2, xOffset, yOffset, zOffsetLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCSliderConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, classcad_1.CCClasses.CCSliderConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -917,11 +864,11 @@ class CAD {
                     }
                     await assemblyBuilderAPI.updateSliderConstraints(drawingId, constrToAdd);
                 },
-                createPlanarConstraint: async (asmId, mate1, mate2, zOffset, xOffsetLimits, yOffsetLimits, zRotationLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createPlanarConstraint: async (id, mate1, mate2, zOffset, xOffsetLimits, yOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCPlanarConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, classcad_1.CCClasses.CCPlanarConstraint, name);
                     if (constraintId != null) {
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
                         await assemblyBuilderAPI.updatePlanarConstraints(drawingId, [
@@ -989,11 +936,11 @@ class CAD {
                     }
                     await assemblyBuilderAPI.updatePlanarConstraints(drawingId, constrToAdd);
                 },
-                createParallelConstraint: async (asmId, mate1, mate2, xOffsetLimits, yOffsetLimits, zOffsetLimits, zRotationLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createParallelConstraint: async (id, mate1, mate2, xOffsetLimits, yOffsetLimits, zOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCParallelConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, classcad_1.CCClasses.CCParallelConstraint, name);
                     if (constraintId != null) {
                         await assemblyBuilderAPI.updateParallelConstraints(drawingId, [
                             {
@@ -1179,10 +1126,10 @@ class CAD {
                         return null;
                     }, partId, ...references);
                 },
-                createWorkCoordSystem: (partId, type, references, coordinateSystem, offset, rotation, inverted = false, local = false, name) => {
+                createWorkCoordSystem: (partId, type, references, offset, rotation, inverted = false, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wCSName = name ? name : 'WorkCoordSystem';
-                        const wCSId = await featureAPI.createWorkGeometry(drawingId, rPartId, classcad_1.CCClasses.CCWorkCoordSystem, wCSName);
+                        const wCSId = await featureAPI.createWorkGeometry(drawingId, rPartId, classcad_1.CCClasses.CCWorkCSys, wCSName);
                         if (wCSId != null) {
                             const offsetParam = {
                                 value: resolveVec(offset),
@@ -1192,7 +1139,7 @@ class CAD {
                                 value: resolveVec(rotation),
                                 isExpr: typeof rotation === 'string',
                             };
-                            await featureAPI.updateWorkCoordSystem(drawingId, wCSId, type, rReferences, coordinateSystem.map(resolveVec), offsetParam, rotationParam, inverted ? 1 : 0, local);
+                            await featureAPI.updateWorkCSys(drawingId, wCSId, type, rReferences, offsetParam, rotationParam, inverted ? 1 : 0);
                             return wCSId;
                         }
                         return null;
@@ -1245,87 +1192,93 @@ class CAD {
                         return null;
                     }, partId, references);
                 },
-                findOrSelect: (partId, type, length, positions) => {
-                    return this.resolve(async ([rPartId]) => {
-                        let filter = core_1.lineSegmentsFilter;
-                        switch (type) {
-                            case 0: // Vertex
-                                filter = core_1.pointFilter;
-                                break;
-                            case 1: // Edge
-                                filter = core_1.lineSegmentsFilter;
-                                break;
-                            case 2: // Loop
-                                filter = core_1.loopFilter;
-                                break;
-                            case 3: // Face
-                                filter = core_1.planeFilter;
-                                break;
-                        }
-                        const geometries = positions
-                            ? await geometryAPI.findGeometriesByPoints(drawingId, rPartId, type, positions.map(p => p.map(resolveVec)))
-                            : await (0, selection_1.waitForSelect)(length, filter, (resolveSelection, items, diff) => {
-                                if (items.length > length - 1) {
-                                    resolveSelection(items.map(i => i.data.graphicId));
-                                    geometryAPI
-                                        .getPointsByGeometries(drawingId, items.map(i => i.data.graphicId))
-                                        .then(points => {
-                                        logPoints(points);
-                                    });
-                                }
+                selectGeometry: (types, count) => {
+                    const drId = this.drawingId;
+                    return this.resolve(async ([]) => {
+                        const filter = (scope, data) => scope === core_1.BuerliScope && types.some(type => type === data);
+                        // Check count param. If not set use by default 1, else check if not < 1
+                        const lCount = count ? (count < 1 ? 1 : count) : 1;
+                        const selections = (await (0, selection_1.waitForSelect)(lCount, filter, (resolveSelection, items, diff) => {
+                            if (items.length > lCount - 1) {
+                                resolveSelection(items);
+                            }
+                        }));
+                        const interactionInfos = [];
+                        for (const selection of selections) {
+                            // Get matching points from selected geometry and add to userData. TODO: Only if in part mode useful?
+                            const points = await geometryAPI.getPointsByGeometries(drawingId, [selection.data.graphicId]);
+                            const matrix = (0, core_1.getDrawing)(drId).api.structure.calculateGlobalTransformation(selection.data.productId);
+                            const clone = selection.data.geometry.clone().applyMatrix4(matrix);
+                            // TODO: Should the transform code be moved to something else than Measure? It's helpful for more cases than just measuring.
+                            const transformedData = core_1.Measure.transform([selection.data], drId)[0];
+                            const interactionInfo = (0, core_1.createInfo)({
+                                objectId: selection.data.container.ownerId,
+                                prodRefId: selection.data.productId,
+                                containerId: selection.data.container.id,
+                                graphicId: selection.data.graphicId,
+                                // objectPath: ?,  TODO: Add path to the root in expanded tree, as soon as available
+                                userData: Object.assign(Object.assign({}, transformedData), { geometry: clone, matchingPoints: points }),
                             });
-                        return geometries;
+                            interactionInfos.push(interactionInfo);
+                        }
+                        return interactionInfos;
+                    });
+                },
+                findGeometry: (partId, type, positions) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const geoms = await geometryAPI.findGeometriesByPoints(drawingId, rPartId, type, positions.map(p => p.map(resolveVec)));
+                        return geoms;
                     }, partId);
                 },
-                getAssemblyFromContainer: (asmName) => {
+                getAssemblyTemplate: (asmName) => {
                     return this.resolve(async ([]) => {
-                        const asmIds = asmUtils.getAssemblyFromContainer(drawingId, asmName);
+                        const asmIds = asmUtils.getAssemblyTemplate(drawingId, asmName);
                         if (asmIds != undefined) {
                             return Array.isArray(asmIds) ? asmIds : [asmIds];
                         }
                         return null;
                     });
                 },
-                getAssemblyNode: (refId, nodeName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const nodeIds = asmUtils.getAssemblyNode(drawingId, rRefId, nodeName);
-                        if (nodeIds != undefined) {
-                            return Array.isArray(nodeIds) ? nodeIds : [nodeIds];
+                getInstance: (id, instanceName) => {
+                    return this.resolve(async ([rId]) => {
+                        const instances = asmUtils.getInstance(drawingId, rId, instanceName);
+                        if (instances != undefined) {
+                            return Array.isArray(instances) ? instances : [instances];
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getProductOfNode: (refIds) => {
-                    return this.resolve(async ([rRefIds]) => {
+                getProductsOfInstances: (instanceIds) => {
+                    return this.resolve(async ([rInstanceIds]) => {
                         const drawing = (0, core_1.getDrawing)(drawingId);
                         const tree = drawing.structure.tree;
                         const products = [];
-                        for (const rRefId of rRefIds) {
-                            const product = asmUtils.findProduct(rRefId, tree);
+                        for (const rInstanceId of rInstanceIds) {
+                            const product = asmUtils.findProduct(rInstanceId, tree);
                             products.push(product);
                         }
                         return products;
-                    }, refIds);
+                    }, instanceIds);
                 },
-                setCurrentNode: (refId) => {
-                    return this.resolve(async ([rRefId]) => {
-                        await assemblyBuilderAPI.setCurrentNode(drawingId, rRefId);
-                    }, refId);
+                setCurrentInstance: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        await assemblyBuilderAPI.setCurrentInstance(drawingId, rId);
+                    }, id);
                 },
-                getCurrentNode: () => {
+                getCurrentInstance: () => {
                     return this.resolve(async () => {
                         const drw = (0, core_1.getDrawing)(drawingId);
-                        return drw.structure.currentNode;
+                        return drw.structure.currentInstance;
                     });
                 },
-                getCoordSysFromNode: (refId) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const coordSys = asmUtils.getCoordSysFromNode(drawingId, rRefId);
+                getTransformation: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        const coordSys = asmUtils.getTransformation(drawingId, rId);
                         if (coordSys != undefined) {
                             return coordSys;
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
                 setCurrentProduct: (productId) => {
                     return this.resolve(async ([rProductId]) => {
@@ -1338,33 +1291,33 @@ class CAD {
                         return drw.structure.currentProduct;
                     });
                 },
-                getPartFromContainer: (partName) => {
+                getPartTemplate: (partName) => {
                     return this.resolve(async ([]) => {
-                        const partIds = asmUtils.getPartFromContainer(drawingId, partName);
+                        const partIds = asmUtils.getPartTemplate(drawingId, partName);
                         if (partIds != undefined) {
                             return Array.isArray(partIds) ? partIds : [partIds];
                         }
                         return null;
                     });
                 },
-                getWorkCoordSystem: (refId, wcsName) => {
-                    return this.resolve(async ([rRefId]) => {
+                getWorkCoordSystem: (id, wcsName) => {
+                    return this.resolve(async ([rId]) => {
                         console.warn('Warning: getWorkCoordSystem() is deprecated, use getWorkGeometry() instead, getWorkCoordSystem() will be removed in a future release.');
-                        const wcsIds = asmUtils.getWorkCoordSystem(drawingId, rRefId, wcsName);
+                        const wcsIds = asmUtils.getWorkCoordSystem(drawingId, rId, wcsName);
                         if (wcsIds != undefined) {
                             return Array.isArray(wcsIds) ? wcsIds : [wcsIds];
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getSketchRegion: (refId, sketchRegionName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const sRIds = partUtils.getSketchRegion(drawingId, rRefId, sketchRegionName);
+                getSketchRegion: (id, sketchRegionName) => {
+                    return this.resolve(async ([rId]) => {
+                        const sRIds = partUtils.getSketchRegion(drawingId, rId, sketchRegionName);
                         if (sRIds != undefined) {
                             return Array.isArray(sRIds) ? sRIds : [sRIds];
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
                 getWorkGeometry: (refId, type, wgName) => {
                     return this.resolve(async ([rRefId]) => {
@@ -1385,9 +1338,9 @@ class CAD {
                         return null;
                     }, refId);
                 },
-                getFastenedConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getFastenedConstraint(drawingId, rRefId, constrName);
+                getFastenedConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getFastenedConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1399,11 +1352,11 @@ class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getFastenedOriginConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getFastenedOriginConstraint(drawingId, rRefId, constrName);
+                getFastenedOriginConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getFastenedOriginConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1414,11 +1367,11 @@ class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getRevoluteConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getRevoluteConstraint(drawingId, rRefId, constrName);
+                getRevoluteConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getRevoluteConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1429,11 +1382,11 @@ class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getSliderConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getSliderConstraint(drawingId, rRefId, constrName);
+                getSliderConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getSliderConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1445,11 +1398,11 @@ class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getPlanarConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getPlanarConstraint(drawingId, rRefId, constrName);
+                getPlanarConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getPlanarConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1462,11 +1415,11 @@ class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getParallelConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getParallelConstraint(drawingId, rRefId, constrName);
+                getParallelConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getParallelConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1479,11 +1432,11 @@ class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getCylindricalConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getCylindricalConstraint(drawingId, rRefId, constrName);
+                getCylindricalConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getCylindricalConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1494,7 +1447,7 @@ class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
                 getFeatureByName: (partId, featureName) => {
                     return this.resolve(async ([rProductId]) => {
@@ -1505,19 +1458,19 @@ class CAD {
                         return null;
                     }, partId);
                 },
-                getGeometryInformation: (objectId) => {
-                    return this.resolve(async ([rProductOrSolidId]) => {
-                        const values = await baseModelerAPI.getGeometryInformation(drawingId, rProductOrSolidId);
+                getGeometryInformation: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        const values = await baseModelerAPI.getGeometryInformation(drawingId, rId);
                         if (values !== null) {
                             return { centerOfGravity: values[0], volume: values[1] };
                         }
                         return null;
-                    }, objectId);
+                    }, id);
                 },
-                removeNodes: (...nodes) => {
-                    return this.resolve(async ([...rNodes]) => {
-                        return assemblyBuilderAPI.removeNodes(drawingId, rNodes);
-                    }, ...nodes);
+                removeInstances: (...instances) => {
+                    return this.resolve(async ([...rInstances]) => {
+                        return assemblyBuilderAPI.removeInstances(drawingId, rInstances);
+                    }, ...instances);
                 },
                 importFeature: (partId, content, format, name) => {
                     return this.resolve(async ([rPartId]) => {
@@ -1573,21 +1526,40 @@ class CAD {
                         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 assemblyBuilderAPI.setNodeTransformation(drawingId, rRefId, rOwnerId, transformation);
-                    }, referenceId, ownerId);
+                transformInstances: async (...instances) => {
+                    var e_11, _a;
+                    const instancesToTransform = [];
+                    try {
+                        for (var instances_2 = __asyncValues(instances), instances_2_1; instances_2_1 = await instances_2.next(), !instances_2_1.done;) {
+                            const instance = instances_2_1.value;
+                            const [rInstanceId] = await new Promise(res => this.resolve(id => res(id), instance.id));
+                            const instanceParam = {
+                                id: rInstanceId,
+                                transformation: instance.transformation,
+                                options: { isLocal: true }, // in non-interactive mode, the transformation is local to the owner
+                            };
+                            instancesToTransform.push(instanceParam);
+                        }
+                    }
+                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    finally {
+                        try {
+                            if (instances_2_1 && !instances_2_1.done && (_a = instances_2.return)) await _a.call(instances_2);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                    }
+                    return assemblyBuilderAPI.transformInstances(drawingId, instancesToTransform);
                 },
-                translate: (partId, featureIds, references, inverted, distance) => {
-                    return this.resolve(async ([rPartId, rFeatureIds, ...rReferences]) => {
+                translate: (partId, operations, references, inverted, distance) => {
+                    return this.resolve(async ([rPartId, rOperations, ...rReferences]) => {
                         const translationId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCTranslation, 'Translate');
                         if (translationId !== null) {
                             const cDrawing = await (0, core_1.getDrawing)(drawingId);
                             const entArray = [];
-                            for (const rFeatureId of rFeatureIds) {
-                                const entity = cDrawing.structure.tree[(await rFeatureId)].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
                                 }
                             }
                             const dist = { value: distance, isExpr: typeof distance === 'string' };
@@ -1595,7 +1567,7 @@ class CAD {
                             return translationId;
                         }
                         return null;
-                    }, partId, featureIds, ...references);
+                    }, partId, operations, ...references);
                 },
                 // TODO: Remove this method. Is it necessary?
                 updateTranslate: (translationId, distance) => {
@@ -1620,11 +1592,11 @@ class CAD {
                 saveToUrl: (url, filetype) => {
                     return baseModelerAPI.saveToUrl(drawingId, url, filetype);
                 },
-                load: (content, type) => {
-                    return baseModelerAPI.load(drawingId, content, type);
+                load: (content, type, options) => {
+                    return baseModelerAPI.load(drawingId, content, type, '', options);
                 },
-                loadFromUrl: (url, filetype) => {
-                    return baseModelerAPI.loadFromUrl(drawingId, url, filetype, true);
+                loadFromUrl: (url, filetype, options) => {
+                    return baseModelerAPI.loadFromUrl(drawingId, url, filetype, true, options);
                 },
                 loadProduct: (content, type, options) => {
                     return assemblyBuilderAPI.loadProduct(drawingId, content, type, '', options);
@@ -1634,6 +1606,7 @@ class CAD {
                 },
                 pick: (partId, type, points) => {
                     return this.resolve(async ([rPartId]) => {
+                        console.warn('Warning: pick() is deprecated, use findGeometry() instead, pick() will be removed in a future release.');
                         const refs = await featureAPI.pick(drawingId, rPartId, type, points.map(resolveVec));
                         if (refs != undefined) {
                             return Array.isArray(refs) ? refs : [refs];
@@ -1684,16 +1657,16 @@ class CAD {
                         return null;
                     }, partId, ...references);
                 },
-                mirror: async (partId, entities, references) => {
+                mirror: async (partId, operations, references) => {
                     const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
-                    const rEntities = await new Promise(res => this.resolve(ids => res(ids), ...entities));
+                    const rOperations = await new Promise(res => this.resolve(ids => res(ids), ...operations));
                     const rReferences = await new Promise(res => this.resolve(paths => res(paths), ...references));
                     const cDrawing = (0, 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]);
+                    for (const rOperation of rOperations) {
+                        const entities = cDrawing.structure.tree[rOperation].children;
+                        if (entities != undefined) {
+                            entArray.push(entities[0]);
                         }
                     }
                     const mirrorId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCMirror, 'Mirror');
@@ -1737,6 +1710,50 @@ class CAD {
                         return asmUtils.getMatePath(drawingId, rRefId);
                     }, refId);
                 },
+                slice: async (partId, operations, reference, sideFlag) => {
+                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
+                    const rOperations = await new Promise(res => this.resolve(ids => res(ids), ...operations));
+                    const [rReference] = await new Promise(res => this.resolve(paths => res(paths), reference));
+                    const cDrawing = (0, core_1.getDrawing)(drawingId);
+                    const entArray = [];
+                    for (const rOperation of rOperations) {
+                        const entities = cDrawing.structure.tree[rOperation].children;
+                        if (entities != undefined && entities.length > 0) {
+                            entArray.push(entities[0]); // use first entity of operation
+                        }
+                    }
+                    const sliceId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCSlice, 'Slice');
+                    if (sliceId != null) {
+                        await featureAPI.openFeature(drawingId, sliceId);
+                        if (entArray.length > 0) {
+                            await featureAPI.updateSlice(drawingId, sliceId, entArray, rReference, sideFlag ? 1 : 0);
+                            await featureAPI.closeFeature(drawingId, sliceId);
+                            return sliceId;
+                        }
+                        await featureAPI.closeFeature(drawingId, sliceId);
+                        await baseModelerAPI.deleteObjects(drawingId, [sliceId]);
+                    }
+                    return null;
+                },
+                sliceBySheet: async (partId, operationToSlice, operationOfSheet, sideFlag) => {
+                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
+                    const [rOperationToSlice] = await new Promise(res => this.resolve(ids => res(ids), operationToSlice));
+                    const [rOperationOfSheet] = await new Promise(res => this.resolve(ids => res(ids), operationOfSheet));
+                    const entityToSlice = (0, core_1.getDrawing)(drawingId).structure.tree[rOperationToSlice].children;
+                    const entityOfSheet = (0, core_1.getDrawing)(drawingId).structure.tree[rOperationOfSheet].children;
+                    const sliceBySheetId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCSliceBySheet, 'SliceBySheet');
+                    if (sliceBySheetId != null) {
+                        await featureAPI.openFeature(drawingId, sliceBySheetId);
+                        if (entityToSlice && entityToSlice.length > 0 && entityOfSheet && entityOfSheet.length > 0) {
+                            await featureAPI.updateSliceBySheet(drawingId, sliceBySheetId, entityToSlice[0], entityOfSheet[0], sideFlag ? 1 : 0);
+                            await featureAPI.closeFeature(drawingId, sliceBySheetId);
+                            return sliceBySheetId;
+                        }
+                        await featureAPI.closeFeature(drawingId, sliceBySheetId);
+                        await baseModelerAPI.deleteObjects(drawingId, [sliceBySheetId]);
+                    }
+                    return null;
+                },
             };
             callback(publicApi);
             resolve(drawingId);