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

package/build/esm/history.js

@@ -7,9 +7,9 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 /* eslint-disable max-lines */
 import { ccAPI, CCClasses, ccUtils, DataType, SVGModusType, } from '@buerli.io/classcad';
-import { api, getDrawing, lineSegmentsFilter, loopFilter, MathUtils, planeFilter, pointFilter, } from '@buerli.io/core';
+import { api, getDrawing, MathUtils, BuerliScope, createInfo, Measure, } from '@buerli.io/core';
 import { Group, Matrix4, Mesh, MeshStandardMaterial, Scene } from 'three';
-import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUtils';
+import { mergeBufferGeometries } from 'three-stdlib';
 import { waitForSelect } from './utils/selection';
 import { getDifferentColoredMeshesFromEntity } from './utils/meshes';
 const featureAPI = ccAPI.feature;
@@ -21,16 +21,6 @@ const geometryAPI = ccAPI.geometry;
 const baseUtils = ccUtils.base;
 const asmUtils = ccUtils.assembly;
 const partUtils = 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
@@ -79,7 +69,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 = mergeBufferGeometries(geometries);
                 bufferGeom.applyMatrix4(transformation);
                 bufferGeomArray.push(bufferGeom);
             }
@@ -116,8 +106,8 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
             const matrix = object.coordinateSystem ? MathUtils.convertToMatrix4(object.coordinateSystem) : new 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) {
@@ -165,7 +155,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 = mergeBufferGeometries(colorMeshesMap[key].meshes.map(m => m.geometry));
                                         mesh.material = new MeshStandardMaterial({
                                             color: colorMeshesMap[key].color,
                                             transparent: colorMeshesMap[key].opacity < 1,
@@ -187,7 +177,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 = mergeBufferGeometries(colorMeshesMap[key].meshes.map(m => m.geometry));
                                     mesh.material = new MeshStandardMaterial({
                                         color: colorMeshesMap[key].color,
                                         transparent: colorMeshesMap[key].opacity < 1,
@@ -213,8 +203,8 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
         const matrix = object.coordinateSystem ? MathUtils.convertToMatrix4(object.coordinateSystem) : new 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) {
@@ -224,28 +214,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;
 };
 export default class CAD {
     constructor() {
@@ -267,31 +240,31 @@ export default 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;
@@ -371,17 +344,17 @@ export default 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, CCClasses.CCLinearPattern, 'LinearPattern');
                         if (patternId != null) {
                             // entities
                             const cDrawing = await getDrawing(drawingId);
                             const entArray = [];
-                            for (const rEntity of rEntities) {
-                                const entity = cDrawing.structure.tree[(await rEntity)].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
                                 }
                             }
                             const distance1Param = {
@@ -429,19 +402,19 @@ export default 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, CCClasses.CCCircularPattern, 'CircularPattern');
                         if (patternId != null) {
                             // entities
                             const cDrawing = await getDrawing(drawingId);
                             const entArray = [];
-                            for (const rEntity of rEntities) {
-                                const entity = cDrawing.structure.tree[(await rEntity)].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
+                            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' };
@@ -457,11 +430,11 @@ export default 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, CCClasses.CCExtrusion, 'Extrusion');
                         if (extrusion) {
                             const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
                             if (sketchLines) {
@@ -483,7 +456,7 @@ export default 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, CCClasses.CCRevolve, 'Revolve');
                         if (revolve) {
                             const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
                             if (sketchLines) {
@@ -495,26 +468,23 @@ export default 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 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, 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]) => {
@@ -567,11 +537,11 @@ export default 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, CCClasses.CCFastenedConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCFastenedConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -631,10 +601,10 @@ export default 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, CCClasses.CCFastenedOriginConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCFastenedOriginConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -686,11 +656,11 @@ export default 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, CCClasses.CCCylindricalConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCCylindricalConstraint, name);
                     if (constraintId != null) {
                         await assemblyBuilderAPI.updateCylindricalConstraints(drawingId, [
                             {
@@ -752,11 +722,11 @@ export default 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, CCClasses.CCRevoluteConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCRevoluteConstraint, name);
                     if (constraintId != null) {
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
                         await assemblyBuilderAPI.updateRevoluteConstraints(drawingId, [
@@ -820,11 +790,11 @@ export default 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, CCClasses.CCSliderConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCSliderConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -892,11 +862,11 @@ export default 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, CCClasses.CCPlanarConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCPlanarConstraint, name);
                     if (constraintId != null) {
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
                         await assemblyBuilderAPI.updatePlanarConstraints(drawingId, [
@@ -964,11 +934,11 @@ export default 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, CCClasses.CCParallelConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCParallelConstraint, name);
                     if (constraintId != null) {
                         await assemblyBuilderAPI.updateParallelConstraints(drawingId, [
                             {
@@ -1154,10 +1124,10 @@ export default 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, CCClasses.CCWorkCoordSystem, wCSName);
+                        const wCSId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkCSys, wCSName);
                         if (wCSId != null) {
                             const offsetParam = {
                                 value: resolveVec(offset),
@@ -1167,7 +1137,7 @@ export default 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;
@@ -1220,87 +1190,93 @@ export default class CAD {
                         return null;
                     }, partId, references);
                 },
-                findOrSelect: (partId, type, length, positions) => {
-                    return this.resolve(async ([rPartId]) => {
-                        let filter = lineSegmentsFilter;
-                        switch (type) {
-                            case 0: // Vertex
-                                filter = pointFilter;
-                                break;
-                            case 1: // Edge
-                                filter = lineSegmentsFilter;
-                                break;
-                            case 2: // Loop
-                                filter = loopFilter;
-                                break;
-                            case 3: // Face
-                                filter = planeFilter;
-                                break;
-                        }
-                        const geometries = positions
-                            ? await geometryAPI.findGeometriesByPoints(drawingId, rPartId, type, positions.map(p => p.map(resolveVec)))
-                            : await 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 === 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 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 = 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 = Measure.transform([selection.data], drId)[0];
+                            const interactionInfo = 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 = 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 = 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]) => {
@@ -1313,33 +1289,33 @@ export default 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]) => {
@@ -1360,9 +1336,9 @@ export default 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,
@@ -1374,11 +1350,11 @@ export default 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,
@@ -1389,11 +1365,11 @@ export default 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,
@@ -1404,11 +1380,11 @@ export default 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,
@@ -1420,11 +1396,11 @@ export default 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,
@@ -1437,11 +1413,11 @@ export default 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,
@@ -1454,11 +1430,11 @@ export default 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,
@@ -1469,7 +1445,7 @@ export default class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
                 getFeatureByName: (partId, featureName) => {
                     return this.resolve(async ([rProductId]) => {
@@ -1480,19 +1456,19 @@ export default 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]) => {
@@ -1548,21 +1524,40 @@ export default 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, CCClasses.CCTranslation, 'Translate');
                         if (translationId !== null) {
                             const cDrawing = await 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' };
@@ -1570,7 +1565,7 @@ export default class CAD {
                             return translationId;
                         }
                         return null;
-                    }, partId, featureIds, ...references);
+                    }, partId, operations, ...references);
                 },
                 // TODO: Remove this method. Is it necessary?
                 updateTranslate: (translationId, distance) => {
@@ -1595,11 +1590,11 @@ export default 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);
@@ -1609,6 +1604,7 @@ export default 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];
@@ -1659,16 +1655,16 @@ export default 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 = 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, CCClasses.CCMirror, 'Mirror');
@@ -1712,6 +1708,50 @@ export default 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 = 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, 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 = getDrawing(drawingId).structure.tree[rOperationToSlice].children;
+                    const entityOfSheet = getDrawing(drawingId).structure.tree[rOperationOfSheet].children;
+                    const sliceBySheetId = await featureAPI.createFeature(drawingId, rPartId, 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);