@buerli.io/headless 0.10.0 → 0.12.0

package/build/esm/solid.js

@@ -1,462 +1,472 @@
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-/* eslint-disable max-lines */
-import { ccAPI } from '@buerli.io/classcad';
-import { api, getDrawing } from '@buerli.io/core';
-import { Group, Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
-import { mergeBufferGeometries } from 'three-stdlib';
-import { getDifferentColoredMeshesFromEntity } from './utils/meshes';
-const solidAPI = ccAPI.solid;
-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 = 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])
- */
-export 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 };
-}
-/**
- * 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;
-        }
-    });
-};
-export default 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 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 ccAPI.baseModeler.requestVisualisationOfObject(drawingId, rSolid);
-                    const entity = await getEntity(drawingId, rSolid);
-                    if (entity != null) {
-                        return mergeBufferGeometries(entity.meshes.map(m => m.geometry));
-                    }
-                },
-                createScene: async (solids, options) => {
-                    var e_1, _a;
-                    await this.queue;
-                    this.queue = Promise.resolve(0);
-                    const scene = new Scene();
-                    scene.name = 'Scene'; // Default name for the scene
-                    const part = new Group();
-                    part.name = 'Part'; // Default name for the part
-                    const _solids = [];
-                    const meshes = [];
-                    try {
-                        for (var solids_1 = __asyncValues(solids), solids_1_1; solids_1_1 = await solids_1.next(), !solids_1_1.done;) {
-                            const solid = solids_1_1.value;
-                            await ccAPI.baseModeler.requestVisualisationOfObject(drawingId, solid);
-                            const cDrawing = getDrawing(drawingId);
-                            const solidObject = cDrawing.structure.tree[solid];
-                            if (solidObject) {
-                                const _solid = new Group();
-                                _solid.name = solidObject.name;
-                                _solid.userData = { id: solidObject.id }; // add solid id to the userData
-                                const entities = solidObject.geometryIdList;
-                                if (entities && entities.length > 0) {
-                                    const entity = cDrawing.geometry.cache[entities[0]];
-                                    if (entity && entity.meshes.length > 0) {
-                                        if (options === null || options === void 0 ? void 0 : options.meshPerGeometry) {
-                                            // Create a mesh for each geometry element
-                                            entity.meshes.forEach(m => {
-                                                const mesh = new Mesh();
-                                                mesh.userData = { id: m.graphicId }; // add graphic id to the userData
-                                                mesh.geometry = m.geometry;
-                                                mesh.material = new MeshStandardMaterial({
-                                                    color: m.color ? m.color : entity.color,
-                                                    transparent: m.opacity ? m.opacity < 1 : entity.opacity < 1,
-                                                    opacity: m.opacity ? m.opacity : entity.opacity,
-                                                });
-                                                _solid.add(mesh);
-                                                meshes.push(mesh);
-                                            });
-                                        }
-                                        else {
-                                            // Merge all geometries into one mesh, sort them by color
-                                            const colorMeshesMap = getDifferentColoredMeshesFromEntity(entity);
-                                            Object.keys(colorMeshesMap).forEach(key => {
-                                                const mesh = new Mesh();
-                                                mesh.geometry = mergeBufferGeometries(colorMeshesMap[key].meshes.map(m => m.geometry));
-                                                mesh.material = new MeshStandardMaterial({
-                                                    color: colorMeshesMap[key].color,
-                                                    transparent: colorMeshesMap[key].opacity < 1,
-                                                    opacity: colorMeshesMap[key].opacity,
-                                                });
-                                                _solid.add(mesh); // Add mesh to solid of the scene
-                                                meshes.push(mesh); // Collect mesh to return later
-                                            });
-                                        }
-                                        part.add(_solid); // Add solid to part of the scene
-                                        _solids.push(_solid); // Collect solid to return later
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (solids_1_1 && !solids_1_1.done && (_a = solids_1.return)) await _a.call(solids_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    scene.add(part); // Add part to the scene
-                    return { scene, part, solids: _solids, meshes };
-                },
-                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 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 = 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, '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 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 => api.getState().api.removeDrawing(drawingId));
-    }
-    destroy() {
-        this.drawingId && api.getState().api.removeDrawing(this.drawingId);
-    }
-}
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+/* eslint-disable max-lines */
+import { ccAPI } from '@buerli.io/classcad';
+import { api, getDrawing } from '@buerli.io/core';
+import { Group, Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
+import { mergeBufferGeometries } from 'three-stdlib';
+import { getDifferentColoredMeshesFromEntity } from './utils/meshes';
+const solidAPI = ccAPI.solid;
+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 = 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])
+ */
+export 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 };
+}
+/**
+ * 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;
+        }
+    });
+};
+export class Solid {
+    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 ccAPI.base.createCCDrawing('solid');
+            if (!drawingId)
+                throw new Error('Drawing could not be created');
+            this.drawingId = drawingId;
+            await solidAPI.init(drawingId);
+            const publicApi = {
+                getDrawingId: () => drawingId,
+                getDrawing: () => getDrawing(drawingId),
+                getState: () => api.getState(),
+                setFacetingParameters: (distanceTol, angleTol) => this.resolve(async () => ccAPI.common.setFacetingParameters(drawingId, distanceTol, angleTol)),
+                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 ccAPI.baseModeler.requestVisualisationOfObject(drawingId, rSolid);
+                    const entity = await getEntity(drawingId, rSolid);
+                    if (entity != null) {
+                        return mergeBufferGeometries(entity.meshes.map(m => m.geometry));
+                    }
+                },
+                createScene: async (solids, options) => {
+                    var e_1, _a;
+                    await this.queue;
+                    this.queue = Promise.resolve(0);
+                    const scene = new Scene();
+                    scene.name = 'Scene'; // Default name for the scene
+                    const part = new Group();
+                    part.name = 'Part'; // Default name for the part
+                    const _solids = [];
+                    const meshes = [];
+                    try {
+                        for (var solids_1 = __asyncValues(solids), solids_1_1; solids_1_1 = await solids_1.next(), !solids_1_1.done;) {
+                            const _solid = solids_1_1.value;
+                            await ccAPI.baseModeler.requestVisualisationOfObject(drawingId, _solid);
+                            const cDrawing = getDrawing(drawingId);
+                            const solidObject = cDrawing.structure.tree[_solid];
+                            if (solidObject) {
+                                const _solidGroup = new Group();
+                                _solidGroup.name = solidObject.name;
+                                _solidGroup.userData = { id: solidObject.id }; // add solid id to the userData
+                                const entities = solidObject.geometryIdList;
+                                if (entities && entities.length > 0) {
+                                    const entity = cDrawing.geometry.cache[entities[0]];
+                                    if (entity && entity.meshes.length > 0) {
+                                        if (options === null || options === void 0 ? void 0 : options.meshPerGeometry) {
+                                            // Create a mesh for each geometry element
+                                            entity.meshes.forEach(m => {
+                                                const mesh = new Mesh();
+                                                mesh.userData = { id: m.graphicId }; // add graphic id to the userData
+                                                mesh.geometry = m.geometry;
+                                                mesh.material = new MeshStandardMaterial({
+                                                    color: m.color ? m.color : entity.color,
+                                                    transparent: m.opacity ? m.opacity < 1 : entity.opacity < 1,
+                                                    opacity: m.opacity ? m.opacity : entity.opacity,
+                                                });
+                                                _solidGroup.add(mesh);
+                                                meshes.push(mesh);
+                                            });
+                                        }
+                                        else {
+                                            // Merge all geometries into one mesh, sort them by color
+                                            const colorMeshesMap = getDifferentColoredMeshesFromEntity(entity);
+                                            Object.keys(colorMeshesMap).forEach(key => {
+                                                const mesh = new Mesh();
+                                                mesh.geometry = mergeBufferGeometries(colorMeshesMap[key].meshes.map(m => m.geometry));
+                                                mesh.material = new MeshStandardMaterial({
+                                                    color: colorMeshesMap[key].color,
+                                                    transparent: colorMeshesMap[key].opacity < 1,
+                                                    opacity: colorMeshesMap[key].opacity,
+                                                });
+                                                _solidGroup.add(mesh); // Add mesh to solid of the scene
+                                                meshes.push(mesh); // Collect mesh to return later
+                                            });
+                                        }
+                                        part.add(_solidGroup); // Add solid to part of the scene
+                                        _solids.push(_solidGroup); // Collect solid to return later
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (solids_1_1 && !solids_1_1.done && (_a = solids_1.return)) await _a.call(solids_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    scene.add(part); // Add part to the scene
+                    return { scene, part, solids: _solids, meshes };
+                },
+                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 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 = 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, '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 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 => api.getState().api.removeDrawing(drawingId));
+    }
+    destroy() {
+        this.drawingId && api.getState().api.removeDrawing(this.drawingId);
+    }
+}
+export class solid extends Solid {
+    constructor() {
+        super();
+        console.warn("Warning: 'solid' is deprecated, use 'Solid' instead, 'solid' will be removed in a future release.");
+    }
+}