@buerli.io/headless 0.7.1 → 0.8.0

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,10 +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] };
@@ -104,7 +77,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);
             }
@@ -190,7 +163,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 +185,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,
@@ -249,29 +222,6 @@ 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);
-    }
-};
 class CAD {
     constructor() {
         this.drawingId = null;
@@ -1179,10 +1129,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 +1142,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,36 +1195,37 @@ 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) => {
+                    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 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({}, selection.data), { 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) => {
@@ -1573,10 +1524,29 @@ 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);
+                transformNodes: async (...nodes) => {
+                    var e_11, _a;
+                    const nodesToTransform = [];
+                    try {
+                        for (var nodes_2 = __asyncValues(nodes), nodes_2_1; nodes_2_1 = await nodes_2.next(), !nodes_2_1.done;) {
+                            const node = nodes_2_1.value;
+                            const [rReferenceId] = await new Promise(res => this.resolve(id => res(id), node.referenceId));
+                            const nodeParam = {
+                                referenceId: rReferenceId,
+                                transformation: node.transformation,
+                                options: { isLocal: true }, // in non-interactive mode, the transformation is local to the owner
+                            };
+                            nodesToTransform.push(nodeParam);
+                        }
+                    }
+                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    finally {
+                        try {
+                            if (nodes_2_1 && !nodes_2_1.done && (_a = nodes_2.return)) await _a.call(nodes_2);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                    }
+                    return assemblyBuilderAPI.transformNodes(drawingId, nodesToTransform);
                 },
                 translate: (partId, featureIds, references, inverted, distance) => {
                     return this.resolve(async ([rPartId, rFeatureIds, ...rReferences]) => {
@@ -1634,6 +1604,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];
@@ -1737,6 +1708,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);

package/build/cjs/solid.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;
@@ -35,13 +12,9 @@ exports.createPolyline = void 0;
 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 meshes_1 = require("./utils/meshes");
 const solidAPI = classcad_1.ccAPI.solid;
-let BufferGeometryUtils = BufferGeometryUtils_;
-if (BufferGeometryUtils.BufferGeometryUtils) {
-    BufferGeometryUtils = BufferGeometryUtils.BufferGeometryUtils;
-}
 const toCCVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
 const toCCNbrVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
 const toArray = (v) => (Array.isArray(v) ? v : v.toArray());
@@ -263,7 +236,7 @@ class CAD {
                     await classcad_1.ccAPI.baseModeler.requestVisualisationOfObject(drawingId, rSolid);
                     const entity = await getEntity(drawingId, rSolid);
                     if (entity != null) {
-                        return BufferGeometryUtils.mergeBufferGeometries(entity.meshes.map(m => m.geometry));
+                        return (0, three_stdlib_1.mergeBufferGeometries)(entity.meshes.map(m => m.geometry));
                     }
                 },
                 createScene: async (solids, options) => {
@@ -310,7 +283,7 @@ class CAD {
                                             const colorMeshesMap = (0, meshes_1.getDifferentColoredMeshesFromEntity)(entity);
                                             Object.keys(colorMeshesMap).forEach(key => {
                                                 const mesh = new three_1.Mesh();
-                                                mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(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,

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, } 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,10 +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] };
@@ -79,7 +75,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);
             }
@@ -165,7 +161,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 +183,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,
@@ -224,29 +220,6 @@ 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);
-    }
-};
 export default class CAD {
     constructor() {
         this.drawingId = null;
@@ -1154,10 +1127,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 +1140,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,36 +1193,37 @@ 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) => {
+                    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 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({}, selection.data), { 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) => {
@@ -1548,10 +1522,29 @@ 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);
+                transformNodes: async (...nodes) => {
+                    var e_11, _a;
+                    const nodesToTransform = [];
+                    try {
+                        for (var nodes_2 = __asyncValues(nodes), nodes_2_1; nodes_2_1 = await nodes_2.next(), !nodes_2_1.done;) {
+                            const node = nodes_2_1.value;
+                            const [rReferenceId] = await new Promise(res => this.resolve(id => res(id), node.referenceId));
+                            const nodeParam = {
+                                referenceId: rReferenceId,
+                                transformation: node.transformation,
+                                options: { isLocal: true }, // in non-interactive mode, the transformation is local to the owner
+                            };
+                            nodesToTransform.push(nodeParam);
+                        }
+                    }
+                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    finally {
+                        try {
+                            if (nodes_2_1 && !nodes_2_1.done && (_a = nodes_2.return)) await _a.call(nodes_2);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                    }
+                    return assemblyBuilderAPI.transformNodes(drawingId, nodesToTransform);
                 },
                 translate: (partId, featureIds, references, inverted, distance) => {
                     return this.resolve(async ([rPartId, rFeatureIds, ...rReferences]) => {
@@ -1609,6 +1602,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];
@@ -1712,6 +1706,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);

package/build/esm/solid.js

@@ -9,13 +9,9 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 import { ccAPI } from '@buerli.io/classcad';
 import { api, getDrawing } from '@buerli.io/core';
 import { Group, Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
-import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUtils';
+import { mergeBufferGeometries } from 'three-stdlib';
 import { getDifferentColoredMeshesFromEntity } from './utils/meshes';
 const solidAPI = ccAPI.solid;
-let BufferGeometryUtils = BufferGeometryUtils_;
-if (BufferGeometryUtils.BufferGeometryUtils) {
-    BufferGeometryUtils = BufferGeometryUtils.BufferGeometryUtils;
-}
 const toCCVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
 const toCCNbrVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
 const toArray = (v) => (Array.isArray(v) ? v : v.toArray());
@@ -236,7 +232,7 @@ export default class CAD {
                     await ccAPI.baseModeler.requestVisualisationOfObject(drawingId, rSolid);
                     const entity = await getEntity(drawingId, rSolid);
                     if (entity != null) {
-                        return BufferGeometryUtils.mergeBufferGeometries(entity.meshes.map(m => m.geometry));
+                        return mergeBufferGeometries(entity.meshes.map(m => m.geometry));
                     }
                 },
                 createScene: async (solids, options) => {
@@ -283,7 +279,7 @@ export default class CAD {
                                             const colorMeshesMap = getDifferentColoredMeshesFromEntity(entity);
                                             Object.keys(colorMeshesMap).forEach(key => {
                                                 const mesh = new Mesh();
-                                                mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(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,

package/build/types/history.d.ts

@@ -1,5 +1,5 @@
-import { BooleanOperationType, ChamferType, FlipType, ReorientedType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, OrientationType, ExtrusionType, BrepElemType, WorkGeomType, SVGModusType, LimitsParam, LimitedValue } from '@buerli.io/classcad';
-import { ObjectIdent, ObjectID, PointMemValue } from '@buerli.io/core';
+import { BooleanOperationType, ChamferType, FlipType, ReorientedType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, OrientationType, ExtrusionType, WorkGeomType, SVGModusType, LimitsParam, LimitedValue } from '@buerli.io/classcad';
+import { DrawingID, ObjectIdent, ObjectID, PointMemValue, GraphicType, InteractionInfo } from '@buerli.io/core';
 import { BufferGeometry, Material, Object3D, Scene } from 'three';
 export declare type Vec = number[] | PointMemValue | THREE.Vector3 | THREE.Euler;
 /**
@@ -338,13 +338,13 @@ export declare type ApiHistory = {
      *
      * // Creates a part template and adds geometry to it
      * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
-     * const wcs1 = await api.createWorkCoordSystem(partTempl1, 'Custom', [], offset1, rot, 0, false, 'wcs1')
-     * const wcs3 = await api.createWorkCoordSystem(partTempl1, 'Custom', [], offset3, rot, 0, false, 'wcs3')
+     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
+     * const wcs3 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset3, rot, false, 'wcs3')
      * api.box(partTempl1, [wcs1], 30, 30, 30)
      *
      * // Creates another part template and adds geometry to it
      * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
-     * const wcs2 = await api.createWorkCoordSystem(partTempl2, 'Custom', [], offset2, rot, 0, false, 'wcs2')
+     * const wcs2 = await api.createWorkCoordSystem(partTempl2, WorkCoordSystemType.WCS_Custom, [], offset2, rot, false, 'wcs2')
      * api.cone(partTempl2, [wcs2], 30, 0.1, 30)
      *
      * // Adds the created part templates as nodes to the root assembly
@@ -397,8 +397,8 @@ export declare type ApiHistory = {
      *
      * // Creates a part template and adds geometry to it
      * const partTempl = await api.createPartAsTemplate('Part_Template')
-     * const wcs1 = await api.createWorkCoordSystem(partTempl, 'Custom', [], offset1, rot, 0, false, 'wcs')
-     * const wcs2 = await api.createWorkCoordSystem(partTempl, 'Custom', [], offset2, rot, 0, false, 'wcs')
+     * const wcs1 = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs')
+     * const wcs2 = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset2, rot, false, 'wcs')
      * api.box(partTempl, [wcs1], 30, 30, 30)
      *
      * // Adds the created part template as a node to the root assembly
@@ -659,12 +659,12 @@ export declare type ApiHistory = {
      *
      * // Creates a part template and adds geometry to it
      * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
-     * const wcs1 = await api.createWorkCoordSystem(partTempl1, 'Custom', [], offset1, rot, 0, false, 'wcs1')
+     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
      * api.box(partTempl1, [wcs1], 30, 30, 30)
      *
      * // Creates another part template and adds geometry to it
      * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
-     * const wcs2 = await api.createWorkCoordSystem(partTempl2, 'Custom', [], offset2, rot, 0, false, 'wcs2')
+     * const wcs2 = await api.createWorkCoordSystem(partTempl2, WorkCoordSystemType.WCS_Custom, [], offset2, rot, false, 'wcs2')
      * api.cone(partTempl2, [wcs2], 30, 0.1, 30)
      *
      * // Adds the created part templates as nodes to the assembly
@@ -695,7 +695,7 @@ export declare type ApiHistory = {
      *
      * // Creates a part template and adds geometry to it
      * const partTempl = await api.createPartAsTemplate('Part_Template')
-     * const wcs = await api.createWorkCoordSystem(partTempl, 'Custom', [], offset, rot, 0, false, 'wcs')
+     * const wcs = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset, rot, false, 'wcs')
      * api.box(partTempl, [wcs], 30, 30, 10)
      *
      * // Adds the created part template as a node to the root assembly
@@ -733,7 +733,7 @@ export declare type ApiHistory = {
      *
      * // Creates a part template and adds geometry to it
      * const partTempl = await api.createPartAsTemplate('Part_Template')
-     * const wcs = await api.createWorkCoordSystem(partTempl, 'Custom', [], offset, rot, 0, false, 'wcs')
+     * const wcs = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset, rot, false, 'wcs')
      * api.box(partTempl, [wcs], 30, 30, 10)
      *
      * // Adds the created part template as a node to the root assembly
@@ -762,7 +762,6 @@ export declare type ApiHistory = {
      * @param offset offset from work coordinate system in x-, y- and z-direction
      * @param rotation rotation around x-, y- and z-axis from work coordinate system
      * @param inverted inverts the constraint between mate1 and mate2
-     * @param local if true, work coordinate system is set in local coordinates of part???
      * @param name name of the work coordinate system, if not set default name = 'WorkCoordSystem'
      * @example
      * // Defines some consts
@@ -779,13 +778,13 @@ export declare type ApiHistory = {
      *
      * // Creates a part template and adds geometry to it
      * const partTempl1 = await api.createPartAsTemplate('Part_Template1')
-     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, 0, false, 'wcs1')
-     * const wcs3 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset3, rot, 0, false, 'wcs3')
+     * const wcs1 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset1, rot, false, 'wcs1')
+     * const wcs3 = await api.createWorkCoordSystem(partTempl1, WorkCoordSystemType.WCS_Custom, [], offset3, rot, false, 'wcs3')
      * api.box(partTempl1, [wcs1], 30, 30, 30)
      *
      * // Creates another part template and adds geometry to it
      * const partTempl2 = await api.createPartAsTemplate('Part_Template2')
-     * const wcs2 = await api.createWorkCoordSystem(partTempl2, WorkCoordSystemType.WCS_Custom, [], offset2, rot, 0, false, 'wcs2')
+     * const wcs2 = await api.createWorkCoordSystem(partTempl2, WorkCoordSystemType.WCS_Custom, [], offset2, rot, false, 'wcs2')
      * api.cone(partTempl2, [wcs2], 30, 0.1, 30)
      *
      * // Adds the created part templates as nodes to the root assembly
@@ -797,7 +796,7 @@ export declare type ApiHistory = {
      * const geoms = await api.createBufferGeometry(rootAsm)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
      */
-    createWorkCoordSystem: (partId: VID, type: WorkCoordSystemType, references: VID[], coordinateSystem: Vec[], offset: Vec, rotation: Vec, inverted: boolean, local: boolean, name?: string) => ID;
+    createWorkCoordSystem: (partId: VID, type: WorkCoordSystemType, references: VID[], offset: Vec, rotation: Vec, inverted: boolean, name?: string) => ID;
     /**
      * Creates a new work plane for the given part
      * @param partId id of the part to add the new work plane to
@@ -899,15 +898,27 @@ export declare type ApiHistory = {
      */
     fillet: (partId: VID, references: VIDs, radius: number | string) => ID;
     /**
-     * Find geometry (vertices, edges, faces, loops) by given positions or selection. If positions parameter is null,
-     * user can select geometry in graphical interface. For all selected geometries this function logs its
-     * relevant points into console, to find the geometry later by points
-     * @param partId id of the part looking for geometry in or selecting them
-     * @param type type of geometry to find or select
-     * @param length number of selections to make before resolving the selection
-     * @param positions array of point arrays where to look for geometry or null if the geometry wants to be selected
+     * Important note: To use this method, you need to add the BuerliGeometry component to your application.
+     * Otherwise the selection of geometry won't work.
+     * @see https://buerli.io/docs/training-for-programmers/More/graphics#3-using-the-buerligeometry-react-component
+     *
+     * Lets the user select geometry in graphical interface. As soon as the geometry of given type has been selected, the method
+     * will return necessary information about it.
+     * @see https://buerli.io/docs/training-for-programmers/history/HowTos/useSelectionInHeadless
+     * @param types array of types to filter user selection.
+     * @param count optional number of selections to make (count must be >= 1). Default = 1.
+     */
+    selectGeometry: (types: GrT[], count?: number) => Promise<InteractionInfo[]>;
+    /**
+     * Find geometries of given type on solids in the given part at the given global positions.
+     * @param partId Id of the part where geometries tried to be found.
+     * @param type Type of the geometry to look for
+     * @param positions Array of elements containing one or more positions to look for the geometry
+     * @example
+     * // Find planes at two different positions
+     * const planes = await api.findGeometry(productId, GraphicType.PLANE, [[{x: 50, y: 50, z: 100}], [{x: 100, y: 50, z: 50}]])
      */
-    findOrSelect: (partId: VID, type: BrepElemType, length: number, positions: Vec[][] | null) => IDs;
+    findGeometry: (partId: VID, type: GrT, positions: Vec[][]) => IDs;
     /**
      * Returns the assembly with given name from assembly container.
      * If asmName is empty, all assemblies from assembly container will be returned.
@@ -1174,14 +1185,18 @@ export declare type ApiHistory = {
         referenceId: VID | ObjectIdent;
     }[]) => Promise<void>;
     /**
-     * Transforms the node with referenceId with the given transformation within an assembly
+     * Transforms the nodes with referenceId with the given transformation within an assembly.
+     * The transformations are local to the nodes parent (owner), which is an assembly.
      *
-     * @param referenceId id of the node to transform
-     * @param ownerId id of the owner (parent) of node we want to transform
-     * @param transformation array of three vectors [origin, xAxis, yAxis]
+     * @param nodes array of node parameter objects. See following descriptions.
+     * @param referenceId id or identifier of the node to transform
+     * @param transformation transformation (origin, xDir, yDir) of the node (local to the owner).
      * @example // tbd
      */
-    transformNode: (referenceId: VID, ownerId: VID, transformation: Transform) => Promise<void>;
+    transformNodes: (...nodes: {
+        referenceId: VID | ObjectIdent;
+        transformation: Transform;
+    }[]) => Promise<void>;
     /**
      * Translates a feature along a given axis.
      * @param partId id ot the part where features will be translated
@@ -1202,6 +1217,8 @@ export declare type ApiHistory = {
      */
     updateTranslate: (translationId: VID, distance: number) => Promise<void>;
     /**
+     * @deprecated use findGeometry() instead, pick() will be removed in a future release.
+     *
      * Returns found vertices, edges or faces depending on
      * given type an points. Given points define where to look for elements.
      * @param partId id of the part to pick elements
@@ -1255,9 +1272,27 @@ export declare type ApiHistory = {
      * @param refId id of the node to set the constraint on
      */
     getMatePath: (refId: VID) => Promise<ObjectID[]>;
+    /**
+     * Slices the entities of the given operations by the given reference.
+     * @param partId id of the part where the slice will be created
+     * @param operations ids of the operations from which its entities will be sliced
+     * @param reference id of the workplane reference to use for the slice
+     * @param sideFlag  flag to toggle which side of the sliced entities will be kept
+     * @return id of the slice operation
+     */
+    slice: (partId: VID, operations: VID[], reference: VID, sideFlag: boolean) => ID;
+    /**
+     * Slices the entity of an operation with a sheet entity of another operation
+     * @param partId id of the part where the slice will be created
+     * @param operationToSlice id of the operation of which its entity will be sliced
+     * @param operationOfSheet id of the operation of which its entity is a sheet and used to slice the entity of operationToSlice
+     * @param sideFlag  flag to toggle which side of the sliced entity will be kept
+     * @return id of the slice by sheet operation
+     */
+    sliceBySheet: (partId: VID, operationToSlice: VID, operationOfSheet: VID, sideFlag: boolean) => ID;
 };
 export default class CAD {
-    private drawingId;
+    drawingId: DrawingID | null;
     queue: Promise<number>;
     constructor();
     resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;
@@ -1283,6 +1318,7 @@ declare type MateParam = {
     flip: FlipType;
     reoriented: ReorientedType;
 };
+declare type GrT = GraphicType.POINT | GraphicType.LINE | GraphicType.ARC | GraphicType.CIRCLE | GraphicType.PLANE | GraphicType.CYLINDER | GraphicType.CONE | GraphicType.SPHERE | GraphicType.NURBSCURVE | GraphicType.NURBSSURFACE;
 export declare type Transform = [Point, Point, Point];
 export declare type DimensionType = {
     productId: VID;

package/build/types/solid.d.ts

@@ -1,4 +1,4 @@
-import { ObjectID } from '@buerli.io/core';
+import { DrawingID, ObjectID } from '@buerli.io/core';
 import { BufferGeometry, Scene, Vector3 } from 'three';
 /**
  * A simple and intuitive javascript based api that incorporates solid operations like
@@ -442,7 +442,7 @@ export declare type ApiNoHistory = {
  */
 export declare function createPolyline(fPts: FilletPoint[]): Polyline;
 export default class CAD {
-    private drawingId;
+    drawingId: DrawingID | null;
     queue: Promise<number>;
     constructor();
     resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;

package/build/types/utils/selection.d.ts

@@ -1,4 +1,4 @@
 import { SelectedItem } from '@buerli.io/core';
 declare type CustomSelect<T> = (resolve: (result: T) => Promise<T>, newItems: SelectedItem[], diff: SelectedItem[]) => void;
-export declare function waitForSelect<T>(length: number, filter: any, onChange: CustomSelect<T>): Promise<number[]>;
+export declare function waitForSelect<T>(length: number, filter: any, onChange: CustomSelect<T>): Promise<SelectedItem<any>[]>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
@@ -20,17 +20,19 @@
     "prettify": "prettier --write \"./{src,tests}/**/*.{js,jsx,ts,tsx,json}\""
   },
   "devDependencies": {
-    "@types/three": "^0.143",
+    "@types/three": "^0.152.1",
     "copyfiles": "^2.1.1",
     "rimraf": "^2.6.3",
-    "three": "^0.143",
+    "three": "^0.153",
+    "three-stdlib": "2.23.5",
     "typescript": "4.8.4"
   },
   "peerDependencies": {
-    "three": ">=0.138"
+    "three": ">=0.138",
+    "three-stdlib": ">=2.11.0"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.7.1",
+    "@buerli.io/classcad": "0.8.0",
     "flat-promise": "^1.0.3"
   }
 }