@buerli.io/headless 0.5.0-beta.1 → 0.5.0-beta.2

package/build/cjs/index.js

@@ -0,0 +1,35 @@
+"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 __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,435 @@
+"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;
+};
+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"));
+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());
+const toEuler = (v) => toArray(v);
+const makeVec = (v) => toCCVec(toArray(v));
+const makeNbrVec = (v) => toCCNbrVec(toArray(v));
+const makeEuler = (v) => toCCVec(toEuler(v));
+const makeNbrEuler = (v) => toCCNbrVec(toEuler(v));
+/**
+ * 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 = (0, 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, radius, 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() {
+        this.drawingId = null;
+        this.queue = Promise.resolve(0);
+        this.queue = Promise.resolve(0);
+    }
+    resolve(callback, ...args) {
+        return (this.queue = this.queue
+            .then(() => Promise.all(args).then(callback))
+            .catch(e => {
+            // catch is necessary to avoid error promises in the queue
+        }));
+    }
+    init(callback) {
+        const promise = new Promise(async (resolve, reject) => {
+            const drawingId = await classcad_1.ccAPI.base.createCCDrawing('solid');
+            if (!drawingId)
+                throw new Error('Drawing could not be created');
+            this.drawingId = drawingId;
+            await solidAPI.init(drawingId);
+            const publicApi = {
+                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);
+                    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 };
+                    group.name = 'Solid';
+                    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) => {
+                    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) => {
+                    return this.resolve(async () => {
+                        if (region instanceof three_1.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) => {
+                    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 rSolidId;
+                    }, solidId, ...bodies);
+                },
+                load: (data) => {
+                    return this.resolve(async () => {
+                        const productId = await solidAPI.load(drawingId, data, 'ofb', true);
+                        if (productId !== null) {
+                            const drawing = (0, core_1.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 three_1.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, 'ofb');
+                    });
+                },
+                scale: (target, pointOrFactor) => {
+                    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 classcad_1.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);
+                },
+            };
+            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/cjs/utils/selection.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForSelect = void 0;
+const core_1 = require("@buerli.io/core");
+const uuid_1 = require("uuid");
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const flat_promise_1 = __importDefault(require("flat-promise"));
+async function waitForSelect(length, filter, onChange) {
+    const id = (0, uuid_1.v4)();
+    const activeDrawingId = core_1.api.getState().drawing.active;
+    const selApi = activeDrawingId && (0, core_1.getDrawing)(activeDrawingId).api.selection;
+    // Set up selection API
+    const { promise, resolve } = (0, flat_promise_1.default)();
+    const change = (selId, items, diff) => {
+        selApi && selApi.setItems(selId, items);
+        if (onChange)
+            onChange(resolve, items, diff);
+    };
+    const unsub = selApi && selApi.createSelector(id, filter, false, [], length, change, change);
+    // Wait for user interaction
+    selApi && selApi.activateSelector(id);
+    const result = await promise;
+    // Unsubscribe from all selections
+    unsub && unsub();
+    selApi && selApi.activateSelector(null);
+    return result;
+}
+exports.waitForSelect = waitForSelect;

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

@@ -803,15 +803,7 @@ export default class CAD {
                 createWorkAxis: (partId, type, references, position, direction, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wAName = name ? name : 'WorkAxis';
-                        const wARefs = rReferences;
-                        const wAId = await featureAPI.createWorkAxis(drawingId, rPartId, {
-                            axisType: type,
-                            references: wARefs,
-                            name: wAName,
-                            position: position,
-                            direction: direction,
-                            local: local,
-                        });
+                        const wAId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkAxis, wAName);
                         if (wAId != null) {
                             const positionParam = {
                                 value: position,
@@ -821,7 +813,7 @@ export default class CAD {
                                 value: direction,
                                 isExpr: typeof direction === 'string',
                             };
-                            await featureAPI.updateWorkAxis(drawingId, wAId, type, wARefs, positionParam, directionParam, local);
+                            await featureAPI.updateWorkAxis(drawingId, wAId, type, rReferences, positionParam, directionParam, local);
                             return wAId;
                         }
                         return null;
@@ -830,24 +822,14 @@ export default class CAD {
                 createWorkCoordSystem: (partId, type, references, coordinateSystem, offset, rotation, inverted, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wCSName = name ? name : 'WorkCoordSystem';
-                        const wCSRefs = rReferences;
-                        const wCSId = await featureAPI.createWorkCoordSystem(drawingId, rPartId, {
-                            coordSystemType: type,
-                            name: wCSName,
-                            references: wCSRefs,
-                            coordinateSystem,
-                            offset,
-                            rotation,
-                            inverted,
-                            local,
-                        });
+                        const wCSId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkCoordSystem, wCSName);
                         if (wCSId != null) {
                             const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
                             const rotationParam = {
                                 value: rotation,
                                 isExpr: typeof rotation === 'string',
                             };
-                            await featureAPI.updateWorkCoordSystem(drawingId, wCSId, type, wCSRefs, coordinateSystem, offsetParam, rotationParam, inverted, local);
+                            await featureAPI.updateWorkCoordSystem(drawingId, wCSId, type, rReferences, coordinateSystem, offsetParam, rotationParam, inverted, local);
                             return wCSId;
                         }
                         return null;
@@ -856,16 +838,7 @@ export default class CAD {
                 createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wPName = name ? name : 'WorkPlane';
-                        const wPRefs = rReferences;
-                        const wPId = await featureAPI.createWorkPlane(drawingId, rPartId, {
-                            planeType: type,
-                            references: wPRefs,
-                            offsetOrAngle: offset,
-                            name: wPName,
-                            position: position,
-                            normal: normal,
-                            local: local,
-                        });
+                        const wPId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkPlane, wPName);
                         if (wPId != undefined) {
                             const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
                             const angleParam = { value: angle, isExpr: typeof angle === 'string' };
@@ -874,7 +847,7 @@ export default class CAD {
                                 isExpr: typeof position === 'string',
                             };
                             const normalParam = { value: normal, isExpr: typeof normal === 'string' };
-                            await featureAPI.updateWorkPlane(drawingId, wPId, type, wPRefs, offsetParam, angleParam, positionParam, normalParam, local);
+                            await featureAPI.updateWorkPlane(drawingId, wPId, type, rReferences, offsetParam, angleParam, positionParam, normalParam, local);
                             return wPId;
                         }
                         return null;
@@ -883,20 +856,13 @@ export default class CAD {
                 createWorkPoint: (partId, type, references, position, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wPTName = name ? name : 'WorkPoint';
-                        const wPTRefs = rReferences;
-                        const wPTId = await featureAPI.createWorkPoint(drawingId, rPartId, {
-                            pointType: type,
-                            references: wPTRefs,
-                            name: wPTName,
-                            position: position,
-                            local: local,
-                        });
+                        const wPTId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkPoint, wPTName);
                         if (wPTId != undefined) {
                             const positionParam = {
                                 value: position,
                                 isExpr: typeof position === 'string',
                             };
-                            await featureAPI.updateWorkPoint(drawingId, wPTId, type, wPTRefs, positionParam, local);
+                            await featureAPI.updateWorkPoint(drawingId, wPTId, type, rReferences, positionParam, local);
                             return wPTId;
                         }
                         return null;

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.5.0-beta.1",
+  "version": "0.5.0-beta.2",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
   "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 clean && npm run build",
-    "clean": "rimraf ./build && rimraf ./tsconfig.tsbuildinfo",
+    "prepack": "npm run clean && npm run build -- --sourceMap false && npm run build:cjs -- --sourceMap false",
+    "clean": "rimraf ./build* && rimraf tsconfig.tsbuildinfo",
     "build": "tsc -v && tsc",
-    "build:dev": "tsc --sourceMap true --declarationMap true",
+    "build:cjs": "tsc --target es2017 --module commonjs --composite false --declaration false --declarationDir null --outDir ./build/cjs",
     "test": "echo no tests yet",
     "lint": "eslint \"./src/**/*.ts?(x)\"",
     "prettify": "prettier --write \"./{src,tests}/**/*.{js,jsx,ts,tsx,json}\""
@@ -30,7 +30,7 @@
     "three": ">=0.138"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.5.0-beta.1",
+    "@buerli.io/classcad": "0.5.0-beta.2",
     "flat-promise": "^1.0.3"
   }
 }