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

package/build/cjs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolyline = exports.history = exports.solid = void 0;
+const history_1 = __importDefault(require("./history"));
+exports.history = history_1.default;
+const solid_1 = __importStar(require("./solid"));
+exports.solid = solid_1.default;
+Object.defineProperty(exports, "createPolyline", { enumerable: true, get: function () { return solid_1.createPolyline; } });
+//#endregion Re-export type definitions

package/build/cjs/solid.js

@@ -0,0 +1,352 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolyline = void 0;
+/* eslint-disable max-lines */
+const classcad_1 = require("@buerli.io/classcad");
+const core_1 = require("@buerli.io/core");
+const three_1 = require("three");
+const BufferGeometryUtils_ = __importStar(require("three/examples/jsm/utils/BufferGeometryUtils"));
+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 classcad_1.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 toArray = (v) => (Array.isArray(v) ? v : v.toArray());
+const toEuler = (v) => toArray(v);
+const makeVec = (v) => toCCVec(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;
+};
+/**
+ * Returns the entity of solid from structure tree
+ * @param drawingId Id of current drawing
+ * @param solid Solid to get entity from
+ */
+const getEntity = async (drawingId, solid) => {
+    const rSolid = await solid;
+    const cDrawing = core_1.getDrawing(drawingId);
+    const object = cDrawing.structure.tree[rSolid];
+    if (object != undefined) {
+        const entities = object.geometryIdList;
+        if (entities != undefined && entities.length > 0) {
+            return cDrawing.geometry.cache[entities[0]];
+        }
+        else {
+            console.warn(`There is no cached entry for ${rSolid}!`, cDrawing.geometry.cache);
+            return null;
+        }
+    }
+    else {
+        console.warn(`There is no cached entry for ${rSolid}!`, cDrawing.geometry.cache);
+        return null;
+    }
+};
+/**
+ * Returns the adjacent points of the fillet arc. These are the points where fillet arc tangentially touches the lines.
+ * @param info contains all information for the fillet, like start- and endpoints of adjacent lines and control point
+ * @param radius radius of the fillet arc
+ */
+const getTouchPoints = (info, radius) => {
+    const controlPos = info.control;
+    const linearTolerance = 1e-3;
+    const dirs = [];
+    const maxDists = [];
+    for (let i = 0; i < 2; i++) {
+        const startPos = info.lineStarts[i];
+        const endPos = info.lineEnds[i];
+        const dir = endPos
+            .clone()
+            .sub(startPos)
+            .normalize();
+        const maxDist = endPos.distanceTo(controlPos);
+        dirs.push(dir);
+        maxDists.push(maxDist);
+    }
+    if (radius + linearTolerance >= Math.min(maxDists[0], maxDists[1])) {
+        return null; // too large fillet
+    }
+    // Calculate distance from controlpt to touchpoint
+    const scalar = Math.abs(radius / Math.tan(getIncludingAngle(info) / 2));
+    return dirs.map(dir => dir
+        .clone()
+        .multiplyScalar(scalar)
+        .add(controlPos));
+};
+/**
+ * Calculates the including angle between two lines. The angle is measured from first to second line counterclockwise. If angle exceeds 180°, measuring is clockwise but negative angle
+ * @param info Info contains information about lines
+ */
+const getIncludingAngle = (info) => {
+    // First line (line to point)
+    const line1 = info.lineEnds[0]
+        .clone()
+        .sub(info.lineStarts[0])
+        .normalize();
+    // Second line (line from point)
+    const line2 = info.lineEnds[1]
+        .clone()
+        .sub(info.lineStarts[1])
+        .normalize();
+    // Angle, measured from first line to second line counterclockwise.
+    // If angle exceeds 180°, measuring is clockwise but negative angle
+    const angle = Math.atan2(line1.x * line2.y - line1.y * line2.x, line1.x * line2.x + line1.y * line2.y);
+    return angle;
+};
+/**
+ * Calculates and returns the including angle between the touchpoints of the fillet. Attention: It is the angle of touchpoints and center of fillet arc and not the one between touchpoints and control point.
+ * @param info
+ */
+const getIncludingBulgeAngle = (info) => {
+    // angle of first line, control point and second line
+    const angle = getIncludingAngle(info);
+    // Opposite angle of the angle which was calculated from control point and its adjacent lines
+    const oppositeAngle = Math.PI - Math.abs(angle);
+    const sign = angle / Math.abs(angle);
+    return oppositeAngle * sign * -1; // -1 because of bulges definition
+};
+/**
+ * Creates a polyline from the given fillet points
+ * @param fPts points of the polyline with its associated fillet radius
+ * @example
+ * // Creates a polyline with three points
+ * const fp0 = { point: new THREE.Vector3(20, 20, 0), radius: 4 }
+ * const fp1 = { point: new THREE.Vector3(40, 0, 0), radius: 2 }
+ * const fp2 = { point: new THREE.Vector3(0, 0, 0), radius: 2 }
+ * const polyline = createPolyline([fp0, fp1, fp2])
+ */
+function createPolyline(fPts) {
+    const newVertices = [];
+    const newBulges = [];
+    for (let i = 0; i < fPts.length; i++) {
+        // if fillet point has radius, calculate fillet info, touchpoints and bulge
+        if (fPts[i].radius > 0) {
+            const j = i - 1 < 0 ? fPts.length - 1 : i - 1;
+            const k = i + 1 > fPts.length - 1 ? 0 : i + 1;
+            const filletInfo = {
+                control: fPts[i].point,
+                lineStarts: [fPts[i].point, fPts[i].point],
+                lineEnds: [fPts[j].point, fPts[k].point],
+            };
+            const touchPts = getTouchPoints(filletInfo, fPts[i].radius); // returns two points
+            if (touchPts != undefined && (touchPts === null || touchPts === void 0 ? void 0 : touchPts.length) > 0) {
+                const angle = getIncludingBulgeAngle(filletInfo);
+                const bulge = Math.tan(angle / 4);
+                newVertices.push(...touchPts);
+                newBulges.push(bulge); // bulge for first point
+                newBulges.push(0); // bulge for second point
+            }
+        }
+        else {
+            newVertices.push(fPts[i].point);
+            newBulges.push(0);
+        }
+    }
+    return { points: newVertices, bulges: newBulges };
+}
+exports.createPolyline = createPolyline;
+/**
+ * Creates the specific curve array from THREE.Shape.curves to draw the region in ClassCAD. It contains the type and all necessary points and control points in a multidimensional array.
+ * @param curves THREE.Shape.curves
+ */
+const makeCCData = (curves) => {
+    return curves.map((curve) => {
+        switch (curve.type) {
+            // [pStart, p1, p2, p3]
+            case 'CubicBezierCurve':
+                return [curve.type, curve.v0.toArray(), curve.v1.toArray(), curve.v2.toArray(), curve.v3.toArray()];
+            // [pStart, p1, p2]
+            case 'QuadraticBezierCurve':
+                return [curve.type, curve.v0.toArray(), curve.v1.toArray(), curve.v2.toArray()];
+            // [p1, p2]
+            case 'LineCurve':
+                return [curve.type, curve.v1.toArray(), curve.v2.toArray()];
+            // [...points]
+            case 'SplineCurve':
+                return [curve.type, curve.points.map((point) => point.toArray())];
+            // [pA, radii, angles, clockwise, rotation]
+            case 'EllipseCurve':
+            case 'ArcCurve':
+                const { aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation } = curve;
+                return [
+                    curve.type,
+                    [aX, aY],
+                    [xRadius, yRadius],
+                    [(aStartAngle / Math.PI) * 180, (aEndAngle / Math.PI) * 180],
+                    aClockwise,
+                    aRotation,
+                ];
+            default:
+                return undefined;
+        }
+    });
+};
+class CAD {
+    constructor(target) {
+        this.drawingId = null;
+        this.queue = Promise.resolve(0);
+        this.queue = Promise.resolve(0);
+        if (typeof target !== 'string')
+            this.target = target;
+        core_1.init({ url: typeof target === 'string' ? target : '' });
+    }
+    init(callback) {
+        const promise = new Promise(async (resolve, reject) => {
+            const drawingId = await classcad_1.ccAPI.base.createCCDrawing('solid', this.target);
+            if (!drawingId)
+                throw new Error('Drawing could not be created');
+            this.drawingId = drawingId;
+            await exec(this, drawingId, 'Solid', 'Init', undefined, false);
+            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),
+                createBufferGeometry: async (solid) => {
+                    await this.queue;
+                    this.queue = Promise.resolve(0);
+                    const rSolid = await solid;
+                    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));
+                    }
+                },
+                createScene: async (solid) => {
+                    await this.queue;
+                    this.queue = Promise.resolve(0);
+                    const rSolid = await solid;
+                    await classcad_1.ccAPI.baseModeler.requestVisualisationOfObject(drawingId, rSolid);
+                    const entity = await getEntity(drawingId, rSolid);
+                    const group = new three_1.Scene();
+                    group.userData = { id: rSolid };
+                    if (entity != null) {
+                        for (const mesh of entity.meshes) {
+                            group.add(new three_1.Mesh(mesh.geometry, new three_1.MeshStandardMaterial({
+                                color: mesh.color,
+                                transparent: mesh.opacity < 1,
+                                opacity: mesh.opacity,
+                            })));
+                        }
+                    }
+                    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),
+                extrude: (height, region) => {
+                    if (region instanceof three_1.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);
+                    }
+                },
+                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 = core_1.getDrawing(drawingId);
+                        const solids = drawing.structure.tree[id].solids;
+                        if (solids !== undefined) {
+                            return solids.map(innerId => drawing.graphic.containers[innerId].owner);
+                        }
+                    }
+                    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 three_1.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);
+                    }
+                },
+                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;
+                        }
+                    }
+                }),
+                scale: (target, pointOrFactor) => {
+                    const lPointOrFactor = typeof pointOrFactor === 'number' ? pointOrFactor : makeVec(pointOrFactor);
+                    return exec(this, drawingId, 'Solid', 'Scale', undefined, false, target, lPointOrFactor);
+                },
+                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);
+        });
+        return () => promise.then(drawingId => core_1.api.getState().api.removeDrawing(drawingId));
+    }
+    destroy() {
+        this.drawingId && core_1.api.getState().api.removeDrawing(this.drawingId);
+    }
+}
+exports.default = CAD;

package/build/{history.js → esm/history.js}

@@ -184,7 +184,7 @@ const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray)
         }
     }
 };
-const createRecursiveScene = async (object, drawingId, root) => {
+const createRecursiveScene = async (object, drawingId, root, options) => {
     let cDrawing = getDrawing(drawingId);
     const tree = cDrawing.structure.tree;
     if (object.link || object.solids) {
@@ -204,15 +204,27 @@ const createRecursiveScene = async (object, drawingId, root) => {
                     meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
             }
             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;
-                for (const mesh of meshes) {
-                    part.add(new Mesh(mesh.geometry, new MeshStandardMaterial({ color: mesh.color, transparent: mesh.opacity < 1, opacity: mesh.opacity })));
+                if (options?.meshPerFace) {
+                    const part = new Group();
+                    part.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
+                    part.matrixAutoUpdate = false;
+                    part.userData = { id: object.id };
+                    part.name = object.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);
                 }
-                root.add(part);
             }
         }
     }
@@ -226,7 +238,7 @@ const createRecursiveScene = async (object, drawingId, root) => {
         root.add(assembly);
         for (const child of object.children) {
             if (tree[child].class === CCClasses.CCProductReference || tree[child].class === CCClasses.CCProductReferenceET) {
-                await createRecursiveScene(tree[child], drawingId, assembly);
+                await createRecursiveScene(tree[child], drawingId, assembly, options);
             }
         }
     }
@@ -251,10 +263,18 @@ export default class CAD {
             const publicApi = {
                 addNode: (productId, ownerId, transformation, name) => {
                     return this.resolve(async ([rProductId, rOwnerId]) => {
-                        ccAPI.assemblyBuilder.setCurrentNode(drawingId, rOwnerId);
                         return ccAPI.assemblyBuilder.addNode(drawingId, rProductId, rOwnerId, transformation, name);
                     }, productId, ownerId);
                 },
+                addNodes: (...nodes) => {
+                    return this.resolve(async ([]) => {
+                        const nodesToAdd = [];
+                        nodes.forEach(node => {
+                            nodesToAdd.push([node.productId, node.ownerId, node.transformation, node.name]);
+                        });
+                        return ccAPI.assemblyBuilder.addNodes(drawingId, nodesToAdd);
+                    });
+                },
                 boolean: (partId, type, entities) => {
                     return this.resolve(async ([rPartId, ...rEntities]) => {
                         const cDrawing = await getDrawing(drawingId);
@@ -418,7 +438,7 @@ export default class CAD {
                     }
                     return undefined;
                 },
-                createScene: async (objectId) => {
+                createScene: async (objectId, options) => {
                     await this.queue;
                     this.queue = Promise.resolve(0);
                     const rObjectId = await objectId;
@@ -427,7 +447,7 @@ export default class CAD {
                     const scene = new Scene();
                     if (rObjectId != null) {
                         const rootObj = structureTree[rObjectId];
-                        await createRecursiveScene(rootObj, drawingId, scene);
+                        await createRecursiveScene(rootObj, drawingId, scene, options);
                     }
                     return scene;
                 },
@@ -653,6 +673,15 @@ export default class CAD {
                         await ccAPI.assemblyBuilder.removeNode(drawingId, rReferenceId, rOwnerId);
                     }, referenceId, ownerId);
                 },
+                removeNodes: (...nodes) => {
+                    return this.resolve(async ([]) => {
+                        const nodesToRemove = [];
+                        nodes.forEach(node => {
+                            nodesToRemove.push([node.referenceId, node.ownerId]);
+                        });
+                        return ccAPI.assemblyBuilder.removeNodes(drawingId, nodesToRemove);
+                    });
+                },
                 importFeature: (partId, content, format, name) => {
                     return this.resolve(async ([rPartId]) => {
                         const featureName = name ? name : 'Import';

package/build/{solid.js → esm/solid.js}

@@ -142,7 +142,7 @@ export function createPolyline(fPts) {
                 lineEnds: [fPts[j].point, fPts[k].point],
             };
             const touchPts = getTouchPoints(filletInfo, fPts[i].radius); // returns two points
-            if (touchPts != undefined && (touchPts === null || touchPts === void 0 ? void 0 : touchPts.length) > 0) {
+            if (touchPts != undefined && touchPts?.length > 0) {
                 const angle = getIncludingBulgeAngle(filletInfo);
                 const bulge = Math.tan(angle / 4);
                 newVertices.push(...touchPts);

package/build/{history.d.ts → types/history.d.ts}

@@ -53,6 +53,18 @@ export declare type ApiHistory = {
      * @image /doc/assets/history/addNode.jpg
      */
     addNode: (productId: VID, ownerId: VID, transformation: Transform, name?: string) => ID;
+    /**
+     * Adds multiple products as nodes to an existing assembly at once
+     * @param nodes array of node parameter objects. See also addNode().
+     * @example // tbd
+     * @image // tbd
+     */
+    addNodes: (...nodes: {
+        productId: number;
+        ownerId: number;
+        transformation: Transform;
+        name?: string;
+    }[]) => IDs;
     /**
      * Creates a boolean operation.
      * @param partId id of the part where the operation will be created on
@@ -326,10 +338,15 @@ export declare type ApiHistory = {
     /**
      * Creates ThreeJS scene from current product
      * @param productId id of the product to create scene from
+     * @param options optional object to define different settings.
+     * @param meshPerFace boolean flag to define if a part/solid will have a mesh for each face
+     * or if the faces will be combined to one mesh
      * @example // tbd
      * @image // tbd
      */
-    createScene: (productId: VID) => Promise<Scene>;
+    createScene: (productId: VID, options?: {
+        meshPerFace?: boolean;
+    }) => Promise<Scene>;
     /**
      * Creates one or more expressions.
      * @param partId id of part where to create the expression
@@ -660,7 +677,7 @@ export declare type ApiHistory = {
      * @example // tbd
      * @image // tbd
      */
-    load: (content: ArrayBuffer, type: DataTypes) => Promise<number | null>;
+    load: (content: ArrayBuffer, type: DataTypes) => Promise<number[] | null>;
     /**
      * Loads a product into the current drawing.
      * @param content data as arraybuffer
@@ -672,7 +689,7 @@ export declare type ApiHistory = {
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
      * @image // tbd
      */
-    loadProduct: (content: ArrayBuffer, type: DataTypes) => Promise<number | null>;
+    loadProduct: (content: ArrayBuffer, type: DataTypes) => Promise<number[] | null>;
     /**
      * Creates a new feature and appends geometry to it. This method can be used to import specific geometry
      * which can be used for further operations like boolean, translations and so on.
@@ -692,6 +709,16 @@ export declare type ApiHistory = {
      * @image // tbd
      */
     removeNode: (referenceId: ObjectID, ownerId: ObjectID) => Promise<void>;
+    /**
+     * Removes multiple nodes from an assembly node at once
+     * @param nodes array of node parameter objects. See also removeNode().
+     * @example // tbd
+     * @image // tbd
+     */
+    removeNodes: (...nodes: {
+        referenceId: number;
+        ownerId: number;
+    }[]) => Promise<void>;
     /**
      * Translates a feature along a given axis.
      * @param partId id ot the part where features will be translated
@@ -763,7 +790,7 @@ declare type Point = {
     y: number;
     z: number;
 };
-declare type Transform = [Point, Point, Point];
+export declare type Transform = [Point, Point, Point];
 declare type BooleanTypes = 'Union' | 'Subtraction' | 'Intersection';
 declare type WCSTypes = 'XYAxisOrigin' | 'Custom';
 declare type WATypes = 'Custom' | 'WorkPoints' | 'PointAndDirection' | 'SketchLine' | 'Curve' | '2Points' | '2Planes';

package/build/{index.d.ts → types/index.d.ts}

@@ -7,9 +7,10 @@ export { solid, history, createPolyline };
  *
  * Please have a look at https://github.com/awv-informatik/buerli/pull/129 for more information.
  */
-import { ApiHistory as ApiHistory1, ConstraintType as ConstraintType1 } from './history';
+import { ApiHistory as ApiHistory1, ConstraintType as ConstraintType1, Transform as Transform1 } from './history';
 export declare type ApiHistory = ApiHistory1;
 export declare type ConstraintType = ConstraintType1;
+export declare type Transform = Transform1;
 import { ApiNoHistory as ApiNoHistory1, FilletPoint as FilletPoint1, Polyline as Polyline1 } from './solid';
 export declare type ApiNoHistory = ApiNoHistory1;
 export declare type Polyline = Polyline1;

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.0.34",
+  "version": "0.0.35-beta.0",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "repository": {},
-  "main": "build/index.js",
-  "module": "build/index.js",
-  "types": "build/index.d.ts",
+  "main": "build/cjs/index.js",
+  "module": "build/esm/index.js",
+  "types": "build/types/index.d.ts",
   "sideEffects": false,
   "scripts": {
     "ver": "npm version",
     "prepack": "npm run build:dist",
     "clean": "rimraf ./build",
-    "build": "echo Typescript: && tsc --version && tsc && npm run build:copy && echo DONE",
-    "build:dist": "npm run clean && echo Typescript: && tsc --version && tsc --sourceMap false && npm run build:copy && echo DONE",
-    "build:copy": "copyfiles -a -u 1 \"./src/**/*.png\" \"./build\"",
+    "build": "npm run build:esm -- --sourceMap true --declaration true --declarationDir ./build/types",
+    "build:dist": "npm run clean && npm run build:esm && npm run build:cjs && npm run build:types && echo DONE",
+    "build:esm": "tsc --target es2020 --module esNext --declaration false --declarationDir null --sourceMap false --outDir ./build/esm",
+    "build:cjs": "tsc --target es2017 --module commonjs --declaration false --declarationDir null --sourceMap false --outDir ./build/cjs",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir ./build/types",
     "test": "echo no tests yet",
     "lint": "eslint \"./src/**/*.ts?(x)\"",
     "prettier": "prettier --write \"./{src,tests}/**/*.{js,jsx,ts,tsx,json}\""
@@ -51,6 +53,6 @@
     "three": ">=0.128"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.0.34"
+    "@buerli.io/classcad": "0.0.35-beta.0"
   }
 }