@buerli.io/headless 0.1.0 → 0.2.1-beta.1

package/build/history.js

@@ -246,6 +246,16 @@ const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray)
         }
     }
 };
+/**
+ * We traverse recursively over structure tree, starting with object and create three objects and meshes
+ * for the scene. Each part or assembly will be turned into groups and subgroups. Solids from parts will be turned
+ * into merged meshes, which are children of the group. Faces of a solid with different color
+ * or transparency will get its own mesh.
+ * @param object root object where we start building the three scene
+ * @param drawingId id of the drawing
+ * @param root the root of the scene
+ * @param options e.g. meshPerFace controls if each face gets a own mesh or if they will be combined/merged
+ */
 const createRecursiveScene = async (object, drawingId, root, options) => {
     let cDrawing = getDrawing(drawingId);
     const tree = cDrawing.structure.tree;
@@ -254,6 +264,7 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
         const solids = object.link ? tree[object.link].solids : object.solids;
         if (solids != undefined) {
             let meshes = [];
+            const cachedSolids = [];
             for (const solid of solids) {
                 let cachedSolid = cDrawing.geometry.cache[solid];
                 if (!cachedSolid) {
@@ -262,30 +273,55 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
                     cDrawing = getDrawing(drawingId); // get current drawing state after request
                     cachedSolid = cDrawing.geometry.cache[solid];
                 }
-                if (cachedSolid)
-                    meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
+                if (cachedSolid) {
+                    if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+                        meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
+                    }
+                    else {
+                        cachedSolids.push(cachedSolid);
+                    }
+                }
             }
-            if (meshes.length > 0) {
-                if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+            // If meshPerFace = true, we create for each face a separat mesh
+            if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+                if (meshes.length > 0) {
                     const part = new Group();
                     part.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
                     part.matrixAutoUpdate = false;
-                    part.userData = { id: object.id };
-                    part.name = object.name;
+                    part.userData = { id: object.id }; // product reference id
+                    part.name = object.name; // product reference name
                     for (const mesh of meshes) {
                         part.add(new Mesh(mesh.geometry, new MeshStandardMaterial({ color: mesh.color, transparent: mesh.opacity < 1, opacity: mesh.opacity })));
                     }
                     root.add(part);
                 }
-                else {
-                    const mesh = new Mesh();
-                    mesh.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
-                    mesh.matrixAutoUpdate = false;
-                    mesh.userData = { id: object.id };
-                    mesh.name = object.name;
-                    mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(meshes.map(m => m.geometry));
-                    mesh.material = new MeshStandardMaterial();
-                    root.add(mesh);
+            }
+            else {
+                if (cachedSolids.length > 0) {
+                    const part = new Group();
+                    part.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
+                    part.matrixAutoUpdate = false;
+                    part.userData = { id: object.id }; // product reference id
+                    part.name = object.name; // product reference name
+                    // A cached solid can have different colored faces, e.g. if a brep has been decorated.
+                    // In that case, we group the meshes with the same color/tranparency
+                    for (const cs of cachedSolids) {
+                        const colorMeshesMap = getDifferentColoredMeshesFromSolid(cs);
+                        Object.keys(colorMeshesMap).forEach(key => {
+                            const coloredMeshes = colorMeshesMap[key];
+                            const mesh = new Mesh();
+                            mesh.userData = { id: cs.container.ownerId }; // solid id
+                            mesh.name = tree[cs.container.ownerId].name; // solid name
+                            mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(coloredMeshes.map(m => m.geometry));
+                            mesh.material = new MeshStandardMaterial({
+                                color: coloredMeshes[0].color,
+                                transparent: coloredMeshes[0].opacity < 1,
+                                opacity: coloredMeshes[0].opacity,
+                            });
+                            part.add(mesh);
+                        });
+                    }
+                    root.add(part);
                 }
             }
         }
@@ -295,8 +331,8 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
         const assembly = new Group();
         assembly.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
         assembly.matrixAutoUpdate = false;
-        assembly.userData = { id: object.id };
-        assembly.name = object.name;
+        assembly.userData = { id: object.id }; // assembly root or product reference id
+        assembly.name = object.name; // assembly root or product reference name
         root.add(assembly);
         for (const child of object.children) {
             if (tree[child].class === CCClasses.CCProductReference || tree[child].class === CCClasses.CCProductReferenceET) {
@@ -305,6 +341,24 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
         }
     }
 };
+/**
+ * Get all meshes in a map, sorted by their color / transparency
+ * @param solid solid to look for the meshes
+ * @returns map (key = color/transparency as string, value = meshes array)
+ */
+const getDifferentColoredMeshesFromSolid = (solid) => {
+    const colorMeshesMap = {};
+    solid.meshes.forEach(mesh => {
+        const key = mesh.color.getHexString() + mesh.opacity.toString();
+        if (colorMeshesMap[key]) {
+            colorMeshesMap[key].push(mesh);
+        }
+        else {
+            colorMeshesMap[key] = [mesh];
+        }
+    });
+    return colorMeshesMap;
+};
 export default class CAD {
     constructor() {
         this.drawingId = null;

package/build/solid.d.ts

@@ -41,7 +41,7 @@ export declare type ApiNoHistory = {
      * api.clearSolids()
      * @image // tbd
      */
-    clearSolids: () => ID;
+    clearSolids: () => Promise<void>;
     /**
      * Clears the target solid in the drawing.
      * @param solidId id of the solid to be deleted
@@ -54,7 +54,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
      * @image // tbd
      */
-    clearSolid: (solidId: VID) => ID;
+    clearSolid: (solidId: VID) => Promise<void>;
     /**
      * Creates a simple cone.
      * @param height height of the cone (z-axis)
@@ -116,7 +116,7 @@ export declare type ApiNoHistory = {
     cylinder: (height: number, diameter: number) => ID;
     /**
      * Returns all adjacent edges of a face or vertex
-     * @param target face or vertex id to get the adjacent edges from
+     * @param breps face or vertex ids to get the adjacent edges from
      * @example
      * // Returns all edges from the top surface of box and adds a fillet on them
      * const boxId = api.box(10, 25, 15)
@@ -127,7 +127,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/edgeLoops.jpg
      */
-    edgeLoops: (target: VIDs) => IDs;
+    edgeLoops: (breps: VIDs) => IDs;
     /**
      * Writes the current solid or specific solids to a stream in stp data format
      * and returns the data.
@@ -157,7 +157,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/extendSolidAtPlane.jpg
      */
-    extendSolidAtPlane: (target: VID, point: Vec, normal: Vec, distance: number) => ID;
+    extendSolidAtPlane: (target: VID, point: Vec, normal: Vec, distance: number) => Promise<void>;
     /**
      * Creates an extrusion.
      * @param height height of extrusion
@@ -244,7 +244,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/mirror.jpg
      */
-    mirror: (solidId: VID, point: Vec, normal: Vec) => ID;
+    mirror: (solidId: VID, point: Vec, normal: Vec) => Promise<void>;
     /**
      * Moves the solid to the given position.
      * @param solidId id of the solid which will be moved
@@ -259,7 +259,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/moveTo.jpg
      */
-    moveTo: (solidId: VID, position: Vec) => ID;
+    moveTo: (solidId: VID, position: Vec) => Promise<void>;
     /**
      * Creates an offset of the solid.
      * @param solidId solid which becomes an offset
@@ -287,12 +287,12 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/pick.jpg
      */
-    pick: (solidId: VID, type: string, ...points: Vec[]) => IDs;
+    pick: (solidId: VID, type: 'vertex' | 'edge' | 'face', ...points: Vec[]) => IDs;
     /**
      * Revolves the given region.
      * @param position position of rotation axis
      * @param direction direction of rotation axis
-     * @param angle angle of rotation
+     * @param angle angle of rotation in rad
      * @param region region which will be revolved, defined by Polyline or THREE.Shape
      * @example
      * // Creates a closed polyline from three points and revolves it
@@ -318,7 +318,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/rotateTo.jpg
      */
-    rotateTo: (solidId: VID, rotationVec: Vec) => ID;
+    rotateTo: (solidId: VID, rotationVec: Vec) => Promise<void>;
     /**
      * Writes the current drawing as native file format to a stream and returns the data.
      * Native file is 'of1', for 'stp' file format use export method.
@@ -348,15 +348,15 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/scale.jpg
      */
-    scale: (solidId: VID, vectorOrFactor: Vec | number) => ID;
+    scale: (solidId: VID, vectorOrFactor: Vec | number) => Promise<void>;
     /**
      * Sets the faceting parameters of graphic objects. This defines how detailed solids will be displayed.
      * @param distanceTol tolerated distance between theoretic and tesselated arc
      * @param angleTol tolerated angle between normal vectors of faces which build an arc
      * @example
      * // Creates a cylinder with low tessellation
-     * const cylinderId = api.cylinder(50, 20)
      * api.setFacetingParams(0.5, 0)
+     * const cylinderId = api.cylinder(50, 20)
      * const geom = await api.createBufferGeometry(cylinderId)
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/setFacetingParams.jpg
@@ -375,7 +375,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/slice.jpg
      */
-    slice: (solidId: VID, point: Vec, normal: Vec) => ID;
+    slice: (solidId: VID, point: Vec, normal: Vec) => Promise<void>;
     /**
      * Creates a simple sphere.
      * @param radius radius of the sphere
@@ -435,6 +435,7 @@ export default class CAD {
     private drawingId;
     queue: Promise<number>;
     constructor();
+    resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;
     init(callback: (api: ApiNoHistory) => void): () => Promise<void>;
     destroy(): void;
 }

package/build/solid.js

@@ -3,34 +3,19 @@ import { ccAPI } from '@buerli.io/classcad';
 import { api, getDrawing } from '@buerli.io/core';
 import { Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
 import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUtils';
+const solidAPI = ccAPI.solid;
 let BufferGeometryUtils = BufferGeometryUtils_;
 if (BufferGeometryUtils.BufferGeometryUtils) {
     BufferGeometryUtils = BufferGeometryUtils.BufferGeometryUtils;
 }
-// Qeued execute, returns the first result and expects it to be an ObjectID or
-// a stream, in case of save() or export() is called
-const exec = (instance, drawing, namespace, fn, stream, returnStream, ...args) => {
-    return (instance.queue = instance.queue.then(() => Promise.all(args).then(resolvedArgs => {
-        return ccAPI.base.callSafeAPI(drawing, namespace, fn, resolvedArgs, stream).then(res => {
-            if (returnStream) {
-                return (res && res.results);
-            }
-            else {
-                return (res && res.results[0].result);
-            }
-        });
-    })));
-};
 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());
 const toEuler = (v) => toArray(v);
 const makeVec = (v) => toCCVec(toArray(v));
+const makeNbrVec = (v) => toCCNbrVec(toArray(v));
 const makeEuler = (v) => toCCVec(toEuler(v));
-const makeBoolean = (instance, drawingId, type) => (target, keepSolid, ...bodies) => {
-    for (const body of bodies)
-        exec(instance, drawingId, 'Solid', type, undefined, false, target, keepSolid, body);
-    return target;
-};
+const makeNbrEuler = (v) => toCCNbrVec(toEuler(v));
 /**
  * Returns the entity of solid from structure tree
  * @param drawingId Id of current drawing
@@ -173,7 +158,7 @@ const makeCCData = (curves) => {
             // [...points]
             case 'SplineCurve':
                 return [curve.type, curve.points.map((point) => point.toArray())];
-            // [pA, radii, angles, clockwise, rotation]
+            // [pA, radius, angles, clockwise, rotation]
             case 'EllipseCurve':
             case 'ArcCurve':
                 const { aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation } = curve;
@@ -196,19 +181,42 @@ export default class CAD {
         this.queue = Promise.resolve(0);
         this.queue = Promise.resolve(0);
     }
+    resolve(callback, ...args) {
+        return (this.queue = this.queue.then(() => Promise.all(args).then(callback)));
+    }
     init(callback) {
         const promise = new Promise(async (resolve, reject) => {
             const drawingId = await ccAPI.base.createCCDrawing('solid');
             if (!drawingId)
                 throw new Error('Drawing could not be created');
             this.drawingId = drawingId;
-            await exec(this, drawingId, 'Solid', 'Init', undefined, false);
+            await solidAPI.init(drawingId);
             const publicApi = {
-                box: (length, width, height) => exec(this, drawingId, 'Solid', 'CreateBox', undefined, false, length, width, height),
-                clearSolids: () => exec(this, drawingId, 'Solid', 'ClearSolids', undefined, false),
-                clearSolid: (target) => exec(this, drawingId, 'Solid', 'ClearSolid', undefined, false, target),
-                cone: (length, diameter1, diameter2) => exec(this, drawingId, 'Solid', 'CreateCone', undefined, false, length, diameter1, diameter2),
-                copy: (target) => exec(this, drawingId, 'Solid', 'Copy', undefined, false, target),
+                box: (length, width, height) => {
+                    return this.resolve(async () => {
+                        return solidAPI.createBox(drawingId, length, width, height);
+                    });
+                },
+                clearSolids: () => {
+                    return this.resolve(async () => {
+                        return solidAPI.clearSolids(drawingId);
+                    });
+                },
+                clearSolid: (target) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.clearSolid(drawingId, rTarget);
+                    }, target);
+                },
+                cone: (length, diameter1, diameter2) => {
+                    return this.resolve(async () => {
+                        return solidAPI.createCone(drawingId, length, diameter1, diameter2);
+                    });
+                },
+                copy: (target) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.copy(drawingId, rTarget);
+                    }, target);
+                },
                 createBufferGeometry: async (solid) => {
                     await this.queue;
                     this.queue = Promise.resolve(0);
@@ -227,6 +235,7 @@ export default class CAD {
                     const entity = await getEntity(drawingId, rSolid);
                     const group = new Scene();
                     group.userData = { id: rSolid };
+                    group.name = 'Solid';
                     if (entity != null) {
                         for (const mesh of entity.meshes) {
                             group.add(new Mesh(mesh.geometry, new MeshStandardMaterial({
@@ -238,78 +247,150 @@ export default class CAD {
                     }
                     return group;
                 },
-                cylinder: (length, diameter) => exec(this, drawingId, 'Solid', 'CreateCylinder', undefined, false, length, diameter),
-                edgeLoops: (target) => exec(this, drawingId, 'Solid', 'EdgeLoops', undefined, false, target).then(async (id) => {
-                    return Array.isArray(id) ? id : [id];
-                }),
-                export: (solidIds) => exec(this, drawingId, 'Solid', 'Export', undefined, true, null, 'stp', solidIds).then(async (resp) => {
-                    if (resp && resp[0].result) {
-                        const res = resp[0];
-                        const key = res.result;
-                        if (key && res.streamData) {
-                            return res.streamData[key] || null;
-                        }
-                    }
-                }),
-                extendSolidAtPlane: (target, point, normal, distance) => exec(this, drawingId, 'Solid', 'SolidExtendAtPlane', undefined, false, target, makeVec(point), makeVec(normal), distance),
+                cylinder: (length, diameter) => {
+                    return this.resolve(async () => {
+                        return solidAPI.createCylinder(drawingId, length, diameter);
+                    });
+                },
+                edgeLoops: (breps) => {
+                    return this.resolve(async ([rBreps]) => {
+                        return solidAPI.edgeLoops(drawingId, rBreps);
+                    }, breps);
+                },
+                export: (solidIds) => {
+                    return this.resolve(async ([rSolidIds]) => {
+                        return solidAPI.export(drawingId, 'stp', rSolidIds);
+                    }, solidIds);
+                },
+                extendSolidAtPlane: (target, point, normal, distance) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.solidExtendAtPlane(drawingId, rTarget, makeNbrVec(point), makeNbrVec(normal), distance);
+                    }, target);
+                },
                 extrude: (height, region) => {
-                    if (region instanceof Shape) {
-                        const curveArray = makeCCData(region.curves);
-                        return exec(this, drawingId, 'Solid', 'CreateExtrudeRegion', undefined, false, makeVec(height), curveArray);
-                    }
-                    else {
-                        return exec(this, drawingId, 'Solid', 'CreateExtrude', undefined, false, makeVec(height), region.points, region.bulges);
-                    }
+                    return this.resolve(async () => {
+                        if (region instanceof Shape) {
+                            const curveArray = makeCCData(region.curves);
+                            return solidAPI.createExtrudeRegion(drawingId, makeNbrVec(height), curveArray);
+                        }
+                        else {
+                            return solidAPI.createExtrude(drawingId, makeNbrVec(height), region.points, region.bulges);
+                        }
+                    });
                 },
-                fillet: (radius, edges) => exec(this, drawingId, 'Solid', 'CreateFillet', undefined, false, radius, edges),
-                import: (data) => exec(this, drawingId, 'Solid', 'Import', { data }, false, 'data', 'stp').then(async (id) => {
-                    return Array.isArray(id) ? id : [id];
-                }),
-                intersect: makeBoolean(this, drawingId, 'Intersect'),
-                load: (data) => exec(this, drawingId, 'Solid', 'Load', { data }, false, 'data', 'of1', true).then(async (id) => {
-                    if (id !== null) {
-                        const drawing = getDrawing(drawingId);
-                        const solids = drawing.structure.tree[id].solids;
-                        if (solids !== undefined) {
-                            return solids.map(innerId => drawing.graphic.containers[innerId].owner);
+                fillet: (radius, edges) => {
+                    return this.resolve(async ([rEdges]) => {
+                        return solidAPI.createFillet(drawingId, radius, rEdges);
+                    }, edges);
+                },
+                import: (data) => {
+                    return this.resolve(async () => {
+                        return solidAPI.import(drawingId, data, 'stp');
+                    });
+                },
+                intersect: (solidId, keepSolid, ...bodies) => {
+                    return this.resolve(async ([rSolidId, ...rBodies]) => {
+                        for (const rBody of rBodies) {
+                            solidAPI.intersect(drawingId, rSolidId, keepSolid, rBody);
                         }
-                    }
-                    return [];
-                }),
-                mirror: (target, point, normal) => exec(this, drawingId, 'Solid', 'Mirror', undefined, false, target, makeVec(point), makeVec(normal)),
-                moveTo: (target, position) => exec(this, drawingId, 'Solid', 'MoveTo', undefined, false, target, makeVec(position)),
-                offset: (target, offsetDistance) => exec(this, drawingId, 'Solid', 'Offset', undefined, false, target, offsetDistance),
-                pick: (target, type, ...points) => exec(this, drawingId, 'Solid', 'Pick', undefined, false, target, type, points.map(makeVec)).then(async (id) => {
-                    return Array.isArray(id) ? id : [id];
-                }),
-                revolve: (position, direction, angle, region) => {
-                    if (region instanceof Shape) {
-                        const curveArray = makeCCData(region.curves);
-                        return exec(this, drawingId, 'Solid', 'CreateRevolveRegion', undefined, false, makeVec(position), makeVec(direction), angle, curveArray);
-                    }
-                    else {
-                        return exec(this, drawingId, 'Solid', 'CreateRevolve', undefined, false, makeVec(position), makeVec(direction), (angle / Math.PI) * 180, region.points, region.bulges);
-                    }
+                        return rSolidId;
+                    }, solidId, ...bodies);
                 },
-                rotateTo: (target, point) => exec(this, drawingId, 'Solid', 'RotateTo', undefined, false, target, makeEuler(point)),
-                save: () => exec(this, drawingId, 'Solid', 'Save', undefined, true, null, 'of1').then(async (resp) => {
-                    if (resp && resp[0].result) {
-                        const res = resp[0];
-                        const key = res.result;
-                        if (key && res.streamData) {
-                            return res.streamData[key] || null;
+                load: (data) => {
+                    return this.resolve(async () => {
+                        const productId = await solidAPI.load(drawingId, data, 'of1', true);
+                        if (productId !== null) {
+                            const drawing = getDrawing(drawingId);
+                            const solids = drawing.structure.tree[productId].solids;
+                            if (solids !== undefined) {
+                                return solids.map(innerId => drawing.graphic.containers[innerId].owner);
+                            }
                         }
-                    }
-                }),
+                        return [];
+                    });
+                },
+                mirror: (target, point, normal) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.mirror(drawingId, rTarget, makeNbrVec(point), makeNbrEuler(normal));
+                    }, target);
+                },
+                moveTo: (target, position) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.moveTo(drawingId, rTarget, makeNbrVec(position));
+                    }, target);
+                },
+                offset: (target, offsetDistance) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.offset(drawingId, rTarget, offsetDistance);
+                    }, target);
+                },
+                pick: (target, type, ...points) => {
+                    return this.resolve(async ([rTarget]) => {
+                        const pts = points.map(pt => makeNbrVec(pt));
+                        const breps = await solidAPI.pick(drawingId, rTarget, type, ...pts);
+                        if (breps !== null) {
+                            return Array.isArray(breps) ? breps : [breps];
+                        }
+                    }, target);
+                },
+                revolve: (position, direction, angle, region) => {
+                    return this.resolve(async () => {
+                        if (region instanceof Shape) {
+                            const curveArray = makeCCData(region.curves);
+                            return solidAPI.createRevolveRegion(drawingId, makeNbrVec(position), makeNbrVec(direction), angle, curveArray);
+                        }
+                        else {
+                            return solidAPI.createRevolve(drawingId, makeNbrVec(position), makeNbrVec(direction), (angle / Math.PI) * 180, region.points, region.bulges);
+                        }
+                    });
+                },
+                rotateTo: (target, point) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.rotateTo(drawingId, rTarget, makeNbrEuler(point));
+                    }, target);
+                },
+                save: () => {
+                    return this.resolve(async () => {
+                        return solidAPI.save(drawingId, 'of1');
+                    });
+                },
                 scale: (target, pointOrFactor) => {
-                    const lPointOrFactor = typeof pointOrFactor === 'number' ? pointOrFactor : makeVec(pointOrFactor);
-                    return exec(this, drawingId, 'Solid', 'Scale', undefined, false, target, lPointOrFactor);
+                    return this.resolve(async ([rTarget]) => {
+                        const lPointOrFactor = typeof pointOrFactor === 'number' ? pointOrFactor : makeNbrVec(pointOrFactor);
+                        return solidAPI.scale(drawingId, rTarget, lPointOrFactor);
+                    }, target);
+                },
+                setFacetingParams: (distanceTol, angleTol) => {
+                    return this.resolve(async () => {
+                        return ccAPI.common.setFacetingParameters(drawingId, distanceTol, angleTol);
+                    });
+                },
+                slice: (target, point, normal) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.slice(drawingId, rTarget, makeNbrVec(point), makeNbrVec(normal));
+                    }, target);
+                },
+                sphere: (radius) => {
+                    return this.resolve(async () => {
+                        return solidAPI.createSphere(drawingId, radius);
+                    });
+                },
+                subtract: (solidId, keepSolid, ...bodies) => {
+                    return this.resolve(async ([rSolidId, ...rBodies]) => {
+                        for (const rBody of rBodies) {
+                            solidAPI.subtract(drawingId, rSolidId, keepSolid, rBody);
+                        }
+                        return rSolidId;
+                    }, solidId, ...bodies);
+                },
+                union: (solidId, keepSolid, ...bodies) => {
+                    return this.resolve(async ([rSolidId, ...rBodies]) => {
+                        for (const rBody of rBodies) {
+                            solidAPI.union(drawingId, rSolidId, keepSolid, rBody);
+                        }
+                        return rSolidId;
+                    }, solidId, ...bodies);
                 },
-                setFacetingParams: (distanceTol, angleTol) => exec(this, drawingId, 'BaseModeler', 'SetFacetingParams', undefined, false, distanceTol, angleTol),
-                slice: (target, point, normal) => exec(this, drawingId, 'Solid', 'Slice', undefined, false, target, makeVec(point), makeVec(normal)),
-                sphere: (radius) => exec(this, drawingId, 'Solid', 'CreateSphere', undefined, false, radius),
-                subtract: makeBoolean(this, drawingId, 'Subtract'),
-                union: makeBoolean(this, drawingId, 'Union'),
             };
             callback(publicApi);
             resolve(drawingId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.1.0",
+  "version": "0.2.1-beta.1",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
@@ -29,6 +29,6 @@
     "three": ">=0.138"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.1.0"
+    "@buerli.io/classcad": "0.2.1-beta.1"
   }
 }