@buerli.io/headless 0.0.35-beta.1 → 0.0.35

package/package.json

@@ -1,22 +1,20 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.0.35-beta.1",
+  "version": "0.0.35",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "repository": {},
-  "main": "build/cjs/index.js",
-  "module": "build/esm/index.js",
-  "types": "build/types/index.d.ts",
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
   "sideEffects": false,
   "scripts": {
     "ver": "npm version",
     "prepack": "npm run build:dist",
     "clean": "rimraf ./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 es2017 --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",
+    "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\"",
     "test": "echo no tests yet",
     "lint": "eslint \"./src/**/*.ts?(x)\"",
     "prettier": "prettier --write \"./{src,tests}/**/*.{js,jsx,ts,tsx,json}\""
@@ -53,6 +51,6 @@
     "three": ">=0.128"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.0.35-beta.1"
+    "@buerli.io/classcad": "0.0.35"
   }
 }

package/build/cjs/history.js

@@ -1,814 +0,0 @@
-"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 });
-/* 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 featureAPI = classcad_1.ccAPI.feature;
-let BufferGeometryUtils = BufferGeometryUtils_;
-if (BufferGeometryUtils.BufferGeometryUtils) {
-    BufferGeometryUtils = BufferGeometryUtils.BufferGeometryUtils;
-}
-// Qeued execute, returns the first result and expects it to be an ObjectID
-const exec = (instance, drawing, namespace, fn, stream, ...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 => {
-            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 getBoxMember = (drawingId, featureId, member) => {
-    const cDrawing = core_1.getDrawing(drawingId);
-    const members = cDrawing.structure.tree[featureId].members;
-    if (members) {
-        switch (member) {
-            case 'width':
-                return members.width.value === undefined ? 10 : Number(members.width.value);
-            case 'length':
-                return members.length.value === undefined ? 10 : Number(members.length.value);
-            case 'height':
-                return members.height.value === undefined ? 10 : Number(members.height.value);
-        }
-    }
-};
-const getDataType = (value) => {
-    switch (typeof value) {
-        case 'number':
-            return classcad_1.DataType.REAL;
-        case 'object':
-            return classcad_1.DataType.POINT;
-        case 'string':
-            return classcad_1.DataType.STRING;
-    }
-};
-const getBoolType = (type) => {
-    switch (type) {
-        case 'Union':
-            return classcad_1.BooleanOperationType.UNION;
-        case 'Subtraction':
-            return classcad_1.BooleanOperationType.SUBTRACTION;
-        case 'Intersection':
-            return classcad_1.BooleanOperationType.INTERSECTION;
-        case undefined:
-            break;
-    }
-};
-const getChamferType = (type) => {
-    switch (type) {
-        case 'Equal_Distance':
-            return classcad_1.ChamferType.EQUAL_DISTANCE;
-        case 'Two_Distances':
-            return classcad_1.ChamferType.TWO_DISTANCES;
-        case 'Distance_And_Angle':
-            return classcad_1.ChamferType.DISTANCE_AND_ANGLE;
-        case undefined:
-            break;
-    }
-};
-const getWCSType = (type) => {
-    switch (type) {
-        case 'XYAxisOrigin':
-            return classcad_1.WorkCoordSystemType.WCS_XYAXISORIGIN;
-        case 'Custom':
-            return classcad_1.WorkCoordSystemType.WCS_CUSTOM;
-        case undefined:
-            break;
-    }
-};
-const getWAType = (type) => {
-    switch (type) {
-        case 'Custom':
-            return classcad_1.WorkAxisType.WA_USERDEFINED;
-        case 'WorkPoints':
-            return classcad_1.WorkAxisType.WA_WORKPOINTS;
-        case 'PointAndDirection':
-            return classcad_1.WorkAxisType.WA_POINTDIRECTION;
-        case 'SketchLine':
-            return classcad_1.WorkAxisType.WA_SKETCHLINE;
-        case 'Curve':
-            return classcad_1.WorkAxisType.WA_CURVE;
-        case '2Points':
-            return classcad_1.WorkAxisType.WA_2POINTS;
-        case '2Planes':
-            return classcad_1.WorkAxisType.WA_2PLANES;
-        case undefined:
-            break;
-    }
-};
-const getWPType = (type) => {
-    switch (type) {
-        case 'Custom':
-            return classcad_1.WorkPlaneType.WP_USERDEFINED;
-        case 'Plane':
-            return classcad_1.WorkPlaneType.WP_PLANE;
-        case 'EdgeAndPoint':
-            return classcad_1.WorkPlaneType.WP_EDGEPOINT;
-        case '3Points':
-            return classcad_1.WorkPlaneType.WP_3POINTS;
-        case 'PointAndNormal':
-            return classcad_1.WorkPlaneType.WP_POINTNORMAL;
-        case 'PointAndFace':
-            return classcad_1.WorkPlaneType.WP_POINTFACE;
-        case 'LinePlaneAndAngle':
-            return classcad_1.WorkPlaneType.WP_LINEPLANEANGLE;
-        case undefined:
-            break;
-    }
-};
-const getWPTType = (type) => {
-    switch (type) {
-        case 'Custom':
-            return classcad_1.WorkPointType.WPT_USERDEFINED;
-        case 'Point':
-            return classcad_1.WorkPointType.WPT_BREPVERTEX;
-        case 'MidPointLine':
-            return classcad_1.WorkPointType.WPT_EDGEMIDPOINT;
-        case 'Center':
-            return classcad_1.WorkPointType.WPT_CENTER;
-        case 'BaryCenter':
-            return classcad_1.WorkPointType.WPT_BARYCENTER;
-        case 'Intersection':
-            return classcad_1.WorkPointType.WPT_INTERSECTION;
-        case 'InnerCircle':
-            return classcad_1.WorkPointType.WPT_INNERCIRCLE;
-        case 'MidPointOf2Points':
-            return classcad_1.WorkPointType.WPT_2POINTS;
-        case undefined:
-            break;
-    }
-};
-const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray) => {
-    let cDrawing = core_1.getDrawing(drawingId);
-    const tree = cDrawing.structure.tree;
-    if (object.link || object.solids) {
-        // Part
-        const solids = object.link ? tree[object.link].solids : object.solids;
-        if (solids != undefined) {
-            let geometries = [];
-            for (const solid of solids) {
-                let cachedSolid = cDrawing.geometry.cache[solid];
-                if (cachedSolid) {
-                    // if solid already cached, take it from cache
-                    geometries = [...geometries, ...cachedSolid.meshes.map(m => m.geometry)];
-                }
-                else {
-                    // else get visualisation from classcad
-                    await classcad_1.ccAPI.baseModeler.requestVisualisationOfEntities(drawingId, [solid]);
-                    cDrawing = core_1.getDrawing(drawingId); // get current drawing state after request
-                    cachedSolid = cDrawing.geometry.cache[solid];
-                    if (cachedSolid) {
-                        geometries = [...geometries, ...cachedSolid.meshes.map(m => m.geometry)];
-                    }
-                    else {
-                        console.warn(`There is no cached entry for ${solid}!`, cDrawing.geometry.cache);
-                    }
-                }
-            }
-            if (geometries.length > 0) {
-                const transformation = cDrawing.api.structure.calculateGlobalTransformation(object.id);
-                const bufferGeom = BufferGeometryUtils.mergeBufferGeometries(geometries);
-                bufferGeom.applyMatrix4(transformation);
-                bufferGeomArray.push(bufferGeom);
-            }
-        }
-    }
-    else if (object.children) {
-        // Assembly
-        for (const child of object.children) {
-            if (tree[child].class === classcad_1.CCClasses.CCProductReference || tree[child].class === classcad_1.CCClasses.CCProductReferenceET) {
-                await createRecursiveBufferGeometry(tree[child], drawingId, bufferGeomArray);
-            }
-        }
-    }
-};
-const createRecursiveScene = async (object, drawingId, root, options) => {
-    let cDrawing = core_1.getDrawing(drawingId);
-    const tree = cDrawing.structure.tree;
-    if (object.link || object.solids) {
-        // Part
-        const solids = object.link ? tree[object.link].solids : object.solids;
-        if (solids != undefined) {
-            let meshes = [];
-            for (const solid of solids) {
-                let cachedSolid = cDrawing.geometry.cache[solid];
-                if (!cachedSolid) {
-                    // else get visualisation from classcad
-                    await classcad_1.ccAPI.baseModeler.requestVisualisationOfEntities(drawingId, [solid]);
-                    cDrawing = core_1.getDrawing(drawingId); // get current drawing state after request
-                    cachedSolid = cDrawing.geometry.cache[solid];
-                }
-                if (cachedSolid)
-                    meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
-            }
-            if (meshes.length > 0) {
-                if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
-                    const part = new three_1.Group();
-                    part.matrix = core_1.MathUtils.convertToMatrix4(object.coordinateSystem);
-                    part.matrixAutoUpdate = false;
-                    part.userData = { id: object.id };
-                    part.name = object.name;
-                    for (const mesh of meshes) {
-                        part.add(new three_1.Mesh(mesh.geometry, new three_1.MeshStandardMaterial({ color: mesh.color, transparent: mesh.opacity < 1, opacity: mesh.opacity })));
-                    }
-                    root.add(part);
-                }
-                else {
-                    const mesh = new three_1.Mesh();
-                    mesh.matrix = core_1.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 three_1.MeshStandardMaterial();
-                    root.add(mesh);
-                }
-            }
-        }
-    }
-    else if (object.children) {
-        // Assembly
-        const assembly = new three_1.Group();
-        assembly.matrix = core_1.MathUtils.convertToMatrix4(object.coordinateSystem);
-        assembly.matrixAutoUpdate = false;
-        assembly.userData = { id: object.id };
-        assembly.name = object.name;
-        root.add(assembly);
-        for (const child of object.children) {
-            if (tree[child].class === classcad_1.CCClasses.CCProductReference || tree[child].class === classcad_1.CCClasses.CCProductReferenceET) {
-                await createRecursiveScene(tree[child], drawingId, assembly, options);
-            }
-        }
-    }
-};
-class CAD {
-    constructor(url) {
-        this.drawingId = null;
-        this.queue = Promise.resolve(0);
-        this.queue = Promise.resolve(0);
-        core_1.init({ url });
-    }
-    resolve(callback, ...args) {
-        // eslint-disable-next-line promise/no-callback-in-promise
-        return (this.queue = this.queue.then(() => Promise.all(args).then(callback)));
-    }
-    init(callback) {
-        const promise = new Promise(async (resolve, reject) => {
-            const drawingId = await classcad_1.ccAPI.base.createCCDrawing();
-            if (!drawingId)
-                throw new Error('Drawing could not be created');
-            this.drawingId = drawingId;
-            const publicApi = {
-                addNode: (productId, ownerId, transformation, name) => {
-                    return this.resolve(async ([rProductId, rOwnerId]) => {
-                        return classcad_1.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 classcad_1.ccAPI.assemblyBuilder.addNodes(drawingId, nodesToAdd);
-                    });
-                },
-                boolean: (partId, type, entities) => {
-                    return this.resolve(async ([rPartId, ...rEntities]) => {
-                        const cDrawing = await core_1.getDrawing(drawingId);
-                        const entArray = [];
-                        for (const rEntity of rEntities) {
-                            const entity = cDrawing.structure.tree[rEntity].children;
-                            if (entity != undefined) {
-                                entArray.push(entity[0]);
-                            }
-                        }
-                        const boolType = getBoolType(type);
-                        if (boolType != undefined) {
-                            const boolId = await featureAPI.createBooleanOperation(drawingId, rPartId, {
-                                type: boolType,
-                                entities: entArray,
-                            });
-                            if (boolId != null) {
-                                await featureAPI.updateBooleanOperation(drawingId, boolId, boolType, entArray);
-                                return boolId;
-                            }
-                        }
-                        return null; // Todo: Exceptions?
-                    }, partId, ...entities);
-                },
-                box: (partId, references, width, length, height) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const boxId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCBox, 'Box');
-                        if (boxId != null) {
-                            const widthParam = { value: width, isExpr: typeof width === 'string' };
-                            const lengthParam = { value: length, isExpr: typeof length === 'string' };
-                            const heightParam = { value: height, isExpr: typeof height === 'string' };
-                            await featureAPI.updateBox(drawingId, boxId, references, widthParam, lengthParam, heightParam);
-                            return boxId;
-                        }
-                        return null;
-                    }, partId);
-                },
-                cylinder: (partId, references, diameter, height) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const cylId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCCylinder, 'Cylinder');
-                        if (cylId != null) {
-                            const diameterParam = { value: diameter, isExpr: typeof length === 'string' };
-                            const heightParam = { value: height, isExpr: typeof height === 'string' };
-                            await featureAPI.updateCylinder(drawingId, cylId, references, diameterParam, heightParam);
-                            return cylId;
-                        }
-                        return null;
-                    }, partId);
-                },
-                chamfer: (partId, type, references, dist1, dist2, angle) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const dist1Param = { value: dist1, isExpr: typeof dist1 === 'string' };
-                        const dist2Param = { value: dist2, isExpr: typeof dist2 === 'string' };
-                        const angleParam = { value: angle, isExpr: typeof angle === 'string' };
-                        const chamferId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCChamfer, 'Chamfer');
-                        const chamferType = getChamferType(type);
-                        if (chamferType != undefined && chamferId != null) {
-                            await featureAPI.updateChamfer(drawingId, chamferId, chamferType, rReferences, dist1Param, dist2Param, angleParam);
-                            return chamferId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                cone: (partId, references, bDiameter, tDiameter, height) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const coneId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCCone, 'Cone');
-                        if (coneId != null) {
-                            const bDiamParam = { value: bDiameter, isExpr: typeof bDiameter === 'string' };
-                            const tDiamParam = { value: tDiameter, isExpr: typeof tDiameter === 'string' };
-                            const heightParam = { value: height, isExpr: typeof height === 'string' };
-                            await featureAPI.updateCone(drawingId, coneId, references, bDiamParam, tDiamParam, heightParam);
-                            return coneId;
-                        }
-                        return null;
-                    }, partId);
-                },
-                createFastenedConstraint: (asmId, mate1, mate2, xOffset, yOffset, zOffset, name) => {
-                    return this.resolve(async ([rAsmId]) => {
-                        const constraintId = await classcad_1.ccAPI.assemblyBuilder.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCFastenedConstraint, name);
-                        if (constraintId != null) {
-                            const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
-                            const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
-                            const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                            await classcad_1.ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, constraintId, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], [mate2.matePath, mate2.wcsId, mate2.flip, mate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
-                            return constraintId;
-                        }
-                        return null;
-                    }, asmId);
-                },
-                updateFastenedConstraint: (constrId, mate1, mate2, xOffset, yOffset, zOffset) => {
-                    return this.resolve(async ([rConstrId]) => {
-                        const xOffsetParam = { value: xOffset, isExpr: false };
-                        const yOffsetParam = { value: yOffset, isExpr: false };
-                        const zOffsetParam = { value: zOffset, isExpr: false };
-                        await classcad_1.ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, rConstrId, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], [mate2.matePath, mate2.wcsId, mate2.flip, mate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
-                    }, constrId);
-                },
-                updateFastenedConstraints: (...constraints) => {
-                    return this.resolve(async ([]) => {
-                        const constrToAdd = [];
-                        constraints.forEach(constr => {
-                            const xOffsetParam = [constr.xOffset, typeof constr.xOffset === 'string'];
-                            const yOffsetParam = [constr.yOffset, typeof constr.yOffset === 'string'];
-                            const zOffsetParam = [constr.zOffset, typeof constr.zOffset === 'string'];
-                            constrToAdd.push([constr.constrId,
-                                [constr.mate1.matePath, constr.mate1.wcsId, constr.mate1.flip, constr.mate1.reoriented],
-                                [constr.mate2.matePath, constr.mate2.wcsId, constr.mate2.flip, constr.mate2.reoriented],
-                                xOffsetParam, yOffsetParam, zOffsetParam]);
-                        });
-                        await classcad_1.ccAPI.assemblyBuilder.updateFastenedConstraints(drawingId, constrToAdd);
-                    });
-                },
-                createFastenedOriginConstraint: (asmId, mate1, xOffset, yOffset, zOffset, name) => {
-                    return this.resolve(async ([rAsmId]) => {
-                        const constraintId = await classcad_1.ccAPI.assemblyBuilder.create3DConstraint(drawingId, rAsmId, classcad_1.CCClasses.CCFastenedOriginConstraint, name);
-                        if (constraintId != null) {
-                            const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
-                            const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
-                            const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                            await classcad_1.ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, constraintId, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
-                            return constraintId;
-                        }
-                        return null;
-                    }, asmId);
-                },
-                updateFastenedOriginConstraint: (constrId, mate1, xOffset, yOffset, zOffset) => {
-                    return this.resolve(async ([rConstrId]) => {
-                        const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
-                        const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
-                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                        await classcad_1.ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, rConstrId, [mate1.matePath, mate1.wcsId, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
-                    }, constrId);
-                },
-                updateFastenedOriginConstraints: (...constraints) => {
-                    return this.resolve(async ([]) => {
-                        const constrToAdd = [];
-                        constraints.forEach(constr => {
-                            const xOffsetParam = [constr.xOffset, typeof constr.xOffset === 'string'];
-                            const yOffsetParam = [constr.yOffset, typeof constr.yOffset === 'string'];
-                            const zOffsetParam = [constr.zOffset, typeof constr.zOffset === 'string'];
-                            constrToAdd.push([constr.constrId,
-                                [constr.mate1.matePath, constr.mate1.wcsId, constr.mate1.flip, constr.mate1.reoriented],
-                                xOffsetParam, yOffsetParam, zOffsetParam]);
-                        });
-                        await classcad_1.ccAPI.assemblyBuilder.updateFastenedOriginConstraints(drawingId, constrToAdd);
-                    });
-                },
-                createBufferGeometry: async (objectId) => {
-                    await this.queue;
-                    this.queue = Promise.resolve(0);
-                    const rObjectId = await objectId;
-                    const cDrawing = core_1.getDrawing(drawingId);
-                    const structureTree = cDrawing.structure.tree;
-                    const bufferGeomArray = [];
-                    if (rObjectId != null) {
-                        const rootObj = structureTree[rObjectId];
-                        await createRecursiveBufferGeometry(rootObj, drawingId, bufferGeomArray);
-                        if (bufferGeomArray.length > 0) {
-                            return bufferGeomArray;
-                        }
-                    }
-                    return undefined;
-                },
-                createScene: async (objectId, options) => {
-                    await this.queue;
-                    this.queue = Promise.resolve(0);
-                    const rObjectId = await objectId;
-                    const cDrawing = core_1.getDrawing(drawingId);
-                    const structureTree = cDrawing.structure.tree;
-                    const scene = new three_1.Scene();
-                    if (rObjectId != null) {
-                        const rootObj = structureTree[rObjectId];
-                        await createRecursiveScene(rootObj, drawingId, scene, options);
-                    }
-                    return scene;
-                },
-                createExpressions: (partId, ...members) => {
-                    return this.resolve(async (resolvedArgs) => {
-                        const membersToAdd = [];
-                        members.forEach(mem => {
-                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
-                            const dataType = getDataType(mem.value);
-                            const featureAPIParam = {
-                                value: mem.value,
-                                isExpr: isExpr,
-                            };
-                            membersToAdd.push([mem.name, featureAPIParam, dataType]);
-                        });
-                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], membersToAdd, [], []);
-                        return success;
-                    }, partId);
-                },
-                createAssemblyAsTemplate: (name) => {
-                    return this.resolve(async ([]) => {
-                        return await classcad_1.ccAPI.assemblyBuilder.createAssemblyAsTemplate(drawingId, name);
-                    });
-                },
-                createRootAssembly: (name) => {
-                    return this.resolve(async ([]) => {
-                        return await classcad_1.ccAPI.assemblyBuilder.createRootAssembly(drawingId, name);
-                    });
-                },
-                createPart: (name) => {
-                    return this.resolve(async ([]) => {
-                        const partName = name ? name : 'Part';
-                        return await featureAPI.newPart(drawingId, partName);
-                    });
-                },
-                createPartAsTemplate: (name) => {
-                    return this.resolve(async ([]) => {
-                        const partName = name ? name : 'Part';
-                        return await classcad_1.ccAPI.assemblyBuilder.createPartAsTemplate(drawingId, partName);
-                    });
-                },
-                createWorkAxis: (partId, type, references, position, direction, local, name) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const wAType = getWAType(type);
-                        const wAName = name ? name : 'WorkAxis';
-                        const wARefs = rReferences;
-                        if (wAType != undefined) {
-                            const wAId = await featureAPI.createWorkAxis(drawingId, rPartId, {
-                                axisType: wAType,
-                                references: wARefs,
-                                name: wAName,
-                                position: position,
-                                direction: direction,
-                                local: local,
-                            });
-                            if (wAId != null) {
-                                const positionParam = {
-                                    value: position,
-                                    isExpr: typeof position === 'string',
-                                };
-                                const directionParam = {
-                                    value: direction,
-                                    isExpr: typeof direction === 'string',
-                                };
-                                await featureAPI.updateWorkAxis(drawingId, wAId, wAType, wARefs, positionParam, directionParam, local);
-                                return wAId;
-                            }
-                        }
-                        return null;
-                    }, partId, references);
-                },
-                createWorkCoordSystem: (partId, type, references, coordinateSystem, offset, rotation, inverted, local, name) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const wCSType = getWCSType(type);
-                        const wCSName = name ? name : 'WorkCoordSystem';
-                        const wCSRefs = rReferences;
-                        if (wCSType != undefined) {
-                            const wCSId = await featureAPI.createWorkCoordSystem(drawingId, rPartId, {
-                                coordSystemType: wCSType,
-                                name: wCSName,
-                                references: wCSRefs,
-                                coordinateSystem,
-                                offset,
-                                rotation,
-                                inverted,
-                                local,
-                            });
-                            if (wCSId != null) {
-                                const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
-                                const rotationParam = {
-                                    value: rotation,
-                                    isExpr: typeof rotation === 'string',
-                                };
-                                await featureAPI.updateWorkCoordSystem(drawingId, wCSId, wCSType, wCSRefs, coordinateSystem, offsetParam, rotationParam, inverted, local);
-                                return wCSId;
-                            }
-                        }
-                        return null;
-                    }, partId, references);
-                },
-                createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const wPType = getWPType(type);
-                        const wPName = name ? name : 'WorkPlane';
-                        const wPRefs = rReferences;
-                        if (wPType != undefined) {
-                            const wPId = await featureAPI.createWorkPlane(drawingId, rPartId, {
-                                planeType: wPType,
-                                references: wPRefs,
-                                offsetOrAngle: offset,
-                                name: wPName,
-                                position: position,
-                                normal: normal,
-                                local: local,
-                            });
-                            if (wPId != undefined) {
-                                const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
-                                const angleParam = { value: angle, isExpr: typeof angle === 'string' };
-                                const positionParam = {
-                                    value: position,
-                                    isExpr: typeof position === 'string',
-                                };
-                                const normalParam = { value: normal, isExpr: typeof normal === 'string' };
-                                await featureAPI.updateWorkPlane(drawingId, wPId, wPType, wPRefs, offsetParam, angleParam, positionParam, normalParam, local);
-                                return wPId;
-                            }
-                        }
-                        return null;
-                    }, partId, references);
-                },
-                createWorkPoint: (partId, type, references, position, local, name) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const wPTType = getWPTType(type);
-                        const wPTName = name ? name : 'WorkPoint';
-                        const wPTRefs = rReferences;
-                        if (wPTType != undefined) {
-                            const wPTId = await featureAPI.createWorkPoint(drawingId, rPartId, {
-                                pointType: wPTType,
-                                references: wPTRefs,
-                                name: wPTName,
-                                position: position,
-                                local: local,
-                            });
-                            if (wPTId != undefined) {
-                                const positionParam = {
-                                    value: position,
-                                    isExpr: typeof position === 'string',
-                                };
-                                await featureAPI.updateWorkPoint(drawingId, wPTId, wPTType, wPTRefs, positionParam, local);
-                                return wPTId;
-                            }
-                        }
-                        return null;
-                    }, partId, references);
-                },
-                fillet: (partId, references, radius) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
-                        const filletId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCConstantRadiusFillet, 'Fillet');
-                        if (filletId != null) {
-                            await featureAPI.updateFillet(drawingId, filletId, rReferences, radiusParam);
-                            return filletId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                getAssemblyFromContainer: (asmName) => {
-                    return this.resolve(async ([]) => {
-                        const asmIds = classcad_1.ccUtils.assembly.getAssemblyFromContainer(drawingId, asmName);
-                        if (asmIds != undefined) {
-                            return Array.isArray(asmIds) ? asmIds : [asmIds];
-                        }
-                        return null;
-                    });
-                },
-                getAssemblyNode: (refId, nodeName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const nodeIds = classcad_1.ccUtils.assembly.getAssemblyNode(drawingId, rRefId, nodeName);
-                        if (nodeIds != undefined) {
-                            return Array.isArray(nodeIds) ? nodeIds : [nodeIds];
-                        }
-                        return null;
-                    }, refId);
-                },
-                getPartFromContainer: (partName) => {
-                    return this.resolve(async ([]) => {
-                        const partIds = classcad_1.ccUtils.assembly.getPartFromContainer(drawingId, partName);
-                        if (partIds != undefined) {
-                            return Array.isArray(partIds) ? partIds : [partIds];
-                        }
-                        return null;
-                    });
-                },
-                getWorkCoordSystem: (refId, wcsName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const wcsIds = classcad_1.ccUtils.assembly.getWorkCoordSystem(drawingId, rRefId, wcsName);
-                        if (wcsIds != undefined) {
-                            return Array.isArray(wcsIds) ? wcsIds : [wcsIds];
-                        }
-                        return null;
-                    }, refId);
-                },
-                getConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constrIds = classcad_1.ccUtils.assembly.getConstraint(drawingId, rRefId, constrName);
-                        if (constrIds != undefined) {
-                            return Array.isArray(constrIds) ? constrIds : [constrIds];
-                        }
-                        return null;
-                    }, refId);
-                },
-                getFeatureByName: (partId, featureName) => {
-                    return this.resolve(async ([rProductId]) => {
-                        const solid = await featureAPI.getFeatureByName(drawingId, rProductId, featureName);
-                        if (solid !== null) {
-                            return solid;
-                        }
-                        return null;
-                    }, partId);
-                },
-                removeNode: (referenceId, ownerId) => {
-                    return this.resolve(async ([rReferenceId, rOwnerId]) => {
-                        await classcad_1.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 classcad_1.ccAPI.assemblyBuilder.removeNodes(drawingId, nodesToRemove);
-                    });
-                },
-                importFeature: (partId, content, format, name) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const featureName = name ? name : 'Import';
-                        const importFeatureId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCImport, featureName);
-                        if (importFeatureId !== null) {
-                            const solids = await featureAPI.loadGeometryStreamToImportFeature(drawingId, importFeatureId, content, format);
-                            if (solids !== null) {
-                                return importFeatureId;
-                            }
-                        }
-                        return null;
-                    }, partId);
-                },
-                translate: (partId, featureIds, references, inverted, distance) => {
-                    return this.resolve(async ([rPartId, rFeatureIds, rReferences]) => {
-                        const translationId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCTranslation, 'Translate');
-                        if (translationId !== null) {
-                            const cDrawing = await core_1.getDrawing(drawingId);
-                            const entArray = [];
-                            for (const rFeatureId of rFeatureIds) {
-                                const entity = cDrawing.structure.tree[rFeatureId].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
-                                }
-                            }
-                            const dist = { value: distance, isExpr: typeof distance === 'string' };
-                            await featureAPI.updateTransformation(drawingId, translationId, entArray, rReferences, inverted, dist);
-                            return translationId;
-                        }
-                        return null;
-                    }, partId, featureIds, references);
-                },
-                updateTranslate: (translationId, distance) => {
-                    return this.resolve(async ([rTranslationId]) => {
-                        const cDrawing = await core_1.getDrawing(drawingId);
-                        const members = cDrawing.structure.tree[rTranslationId].members;
-                        if (members !== null && members !== undefined) {
-                            const entArray = members['bodiesToTransform'].members.map(m => m.value);
-                            const references = members['references'].members.map(m => m.value);
-                            const inverted = members['inverted'].value;
-                            const dist = distance !== null ? distance : members['translationDistance'].value;
-                            const distParam = { value: dist, isExpr: typeof distance === 'string' };
-                            await featureAPI.openFeature(drawingId, rTranslationId);
-                            await featureAPI.updateTransformation(drawingId, rTranslationId, entArray, references, inverted, distParam);
-                            await featureAPI.closeFeature(drawingId, rTranslationId);
-                        }
-                    }, translationId);
-                },
-                save: (type) => {
-                    return classcad_1.ccAPI.baseModeler.save(drawingId, type);
-                },
-                load: (content, type) => {
-                    return classcad_1.ccAPI.baseModeler.load(drawingId, content, type);
-                },
-                loadProduct: (content, type) => {
-                    return classcad_1.ccAPI.assemblyBuilder.loadProduct(drawingId, content, type);
-                },
-                pick: (partId, type, points) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const refs = await featureAPI.pick(drawingId, rPartId, type, points);
-                        if (refs != undefined) {
-                            return Array.isArray(refs) ? refs : [refs];
-                        }
-                        return null;
-                    }, partId);
-                },
-                setExpressions: (partId, ...members) => {
-                    return this.resolve(async (resolvedArgs) => {
-                        const membersToModify = [];
-                        members.forEach(mem => {
-                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
-                            const featureAPIParam = {
-                                value: mem.value,
-                                isExpr: isExpr,
-                            };
-                            membersToModify.push([mem.name, featureAPIParam]);
-                        });
-                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], [], membersToModify, []);
-                        return success;
-                    }, partId);
-                },
-                deleteExpressions: (partId, members) => {
-                    return this.resolve(async (resolvedArgs) => {
-                        const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], [], [], members);
-                        return success;
-                    }, partId);
-                },
-                sphere: (partId, references, radius) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const sphereId = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCSphere, 'Sphere');
-                        if (sphereId != null) {
-                            const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
-                            await featureAPI.updateSphere(drawingId, sphereId, references, radiusParam);
-                            return sphereId;
-                        }
-                        return null;
-                    }, partId);
-                },
-            };
-            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/index.js

@@ -1,31 +0,0 @@
-"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

@@ -1,352 +0,0 @@
-"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;