@buerli.io/headless 0.13.1-beta.1 → 0.13.1-beta.10

package/build/cjs/index.js

@@ -25,12 +25,12 @@ Object.defineProperty(exports, "OrientationType", { enumerable: true, get: funct
 Object.defineProperty(exports, "ExtrusionType", { enumerable: true, get: function () { return classcad_1.ExtrusionType; } });
 Object.defineProperty(exports, "SVGModusType", { enumerable: true, get: function () { return classcad_1.SVGModusType; } });
 // Re-export types form @buerli.io/core for easier usage
-var core_1 = require("@buerli.io/core");
-Object.defineProperty(exports, "GraphicType", { enumerable: true, get: function () { return core_1.GraphicType; } });
-Object.defineProperty(exports, "ContainerType", { enumerable: true, get: function () { return core_1.ContainerType; } });
-Object.defineProperty(exports, "MeshTypes", { enumerable: true, get: function () { return core_1.MeshTypes; } });
-Object.defineProperty(exports, "EdgeTypes", { enumerable: true, get: function () { return core_1.EdgeTypes; } });
-Object.defineProperty(exports, "CurveTypes", { enumerable: true, get: function () { return core_1.CurveTypes; } });
-Object.defineProperty(exports, "EntityTypes", { enumerable: true, get: function () { return core_1.EntityTypes; } });
-Object.defineProperty(exports, "PointTypes", { enumerable: true, get: function () { return core_1.PointTypes; } });
+var classcad_2 = require("@buerli.io/classcad");
+Object.defineProperty(exports, "GraphicType", { enumerable: true, get: function () { return classcad_2.GraphicType; } });
+Object.defineProperty(exports, "ContainerType", { enumerable: true, get: function () { return classcad_2.ContainerType; } });
+Object.defineProperty(exports, "MeshTypes", { enumerable: true, get: function () { return classcad_2.MeshTypes; } });
+Object.defineProperty(exports, "EdgeTypes", { enumerable: true, get: function () { return classcad_2.EdgeTypes; } });
+Object.defineProperty(exports, "CurveTypes", { enumerable: true, get: function () { return classcad_2.CurveTypes; } });
+Object.defineProperty(exports, "EntityTypes", { enumerable: true, get: function () { return classcad_2.EntityTypes; } });
+Object.defineProperty(exports, "PointTypes", { enumerable: true, get: function () { return classcad_2.PointTypes; } });
 //#endregion Re-export type definitions

package/build/cjs/solid.js

@@ -15,7 +15,6 @@ const three_1 = require("three");
 const three_stdlib_1 = require("three-stdlib");
 const meshes_1 = require("./utils/meshes");
 const isShape = (entity) => entity && entity.type === 'Shape';
-const solidAPI = classcad_1.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());
@@ -199,46 +198,47 @@ class Solid {
     }
     init(callback) {
         const promise = new Promise(async (resolve, reject) => {
-            const drawingId = await classcad_1.ccAPI.base.createCCDrawing('solid');
+            const drawingId = await classcad_1.BuerliCadFacade.utils.connect('solid');
             if (!drawingId)
-                throw new Error('Drawing could not be created');
+                throw new Error('Connection/Drawing could not be created');
             this.drawingId = drawingId;
-            await solidAPI.init(drawingId);
+            const { solid: solidAPI, baseModeler: baseModelerAPI, common: commonAPI } = (0, classcad_1.createApi)(drawingId).v0;
+            await solidAPI.init();
             const publicApi = {
                 getDrawingId: () => drawingId,
                 getDrawing: () => (0, core_1.getDrawing)(drawingId),
                 getState: () => core_1.api.getState(),
-                setFacetingParameters: (distanceTol, angleTol) => this.resolve(async () => classcad_1.ccAPI.common.setFacetingParameters(drawingId, distanceTol, angleTol)),
+                setFacetingParameters: (distanceTol, angleTol) => this.resolve(async () => commonAPI.setFacetingParameters(distanceTol, angleTol)),
                 box: (length, width, height) => {
                     return this.resolve(async () => {
-                        return solidAPI.createBox(drawingId, length, width, height);
+                        return solidAPI.createBox(length, width, height);
                     });
                 },
                 clearSolids: () => {
                     return this.resolve(async () => {
-                        return solidAPI.clearSolids(drawingId);
+                        return solidAPI.clearSolids();
                     });
                 },
                 clearSolid: (target) => {
                     return this.resolve(async ([rTarget]) => {
-                        return solidAPI.clearSolid(drawingId, rTarget);
+                        return solidAPI.clearSolid(rTarget);
                     }, target);
                 },
                 cone: (length, diameter1, diameter2) => {
                     return this.resolve(async () => {
-                        return solidAPI.createCone(drawingId, length, diameter1, diameter2);
+                        return solidAPI.createCone(length, diameter1, diameter2);
                     });
                 },
                 copy: (target) => {
                     return this.resolve(async ([rTarget]) => {
-                        return solidAPI.copy(drawingId, rTarget);
+                        return solidAPI.copy(rTarget);
                     }, target);
                 },
                 createBufferGeometry: async (_solid) => {
                     await this.queue;
                     this.queue = Promise.resolve(0);
                     const rSolid = await _solid;
-                    await classcad_1.ccAPI.baseModeler.requestVisualisationOfObject(drawingId, rSolid);
+                    await baseModelerAPI.requestVisualisationOfObject(rSolid);
                     const entity = await getEntity(drawingId, rSolid);
                     if (entity != null) {
                         return (0, three_stdlib_1.mergeBufferGeometries)(entity.meshes.map(m => m.geometry));
@@ -257,7 +257,7 @@ class Solid {
                     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 classcad_1.ccAPI.baseModeler.requestVisualisationOfObject(drawingId, _solid);
+                            await baseModelerAPI.requestVisualisationOfObject(_solid);
                             const cDrawing = (0, core_1.getDrawing)(drawingId);
                             const solidObject = cDrawing.structure.tree[_solid];
                             if (solidObject) {
@@ -317,56 +317,56 @@ class Solid {
                 },
                 cylinder: (length, diameter) => {
                     return this.resolve(async () => {
-                        return solidAPI.createCylinder(drawingId, length, diameter);
+                        return solidAPI.createCylinder(length, diameter);
                     });
                 },
                 edgeLoops: (breps) => {
                     return this.resolve(async ([rBreps]) => {
-                        return solidAPI.edgeLoops(drawingId, rBreps);
+                        return solidAPI.edgeLoops(rBreps);
                     }, breps);
                 },
                 export: (solidIds) => {
                     return this.resolve(async ([rSolidIds]) => {
-                        return solidAPI.export(drawingId, 'stp', rSolidIds);
+                        return solidAPI.export('stp', rSolidIds);
                     }, solidIds);
                 },
                 extendSolidAtPlane: (target, point, normal, distance) => {
                     return this.resolve(async ([rTarget]) => {
-                        return solidAPI.solidExtendAtPlane(drawingId, rTarget, makeNbrVec(point), makeNbrVec(normal), distance);
+                        return solidAPI.solidExtendAtPlane(rTarget, makeNbrVec(point), makeNbrVec(normal), distance);
                     }, target);
                 },
                 extrude: (height, region) => {
                     return this.resolve(async () => {
                         if (isShape(region)) {
                             const curveArray = makeCCData(region.curves);
-                            return solidAPI.createExtrudeRegion(drawingId, makeNbrVec(height), curveArray);
+                            return solidAPI.createExtrudeRegion(makeNbrVec(height), curveArray);
                         }
                         else {
-                            return solidAPI.createExtrude(drawingId, makeNbrVec(height), region.points, region.bulges);
+                            return solidAPI.createExtrude(makeNbrVec(height), region.points, region.bulges);
                         }
                     });
                 },
                 fillet: (radius, edges) => {
                     return this.resolve(async ([rEdges]) => {
-                        return solidAPI.createFillet(drawingId, radius, rEdges);
+                        return solidAPI.createFillet(radius, rEdges);
                     }, edges);
                 },
                 import: (data) => {
                     return this.resolve(async () => {
-                        return solidAPI.import(drawingId, data, 'stp');
+                        return solidAPI.import(data, 'stp');
                     });
                 },
                 intersect: (solidId, keepSolid, ...bodies) => {
                     return this.resolve(async ([rSolidId, ...rBodies]) => {
                         for (const rBody of rBodies) {
-                            solidAPI.intersect(drawingId, rSolidId, keepSolid, rBody);
+                            solidAPI.intersect(rSolidId, keepSolid, rBody);
                         }
                         return rSolidId;
                     }, solidId, ...bodies);
                 },
                 load: (data) => {
                     return this.resolve(async () => {
-                        const productId = await solidAPI.load(drawingId, data, 'ofb', true);
+                        const productId = await solidAPI.load(data, 'ofb', true);
                         if (productId !== null) {
                             const drawing = (0, core_1.getDrawing)(drawingId);
                             const solids = drawing.structure.tree[productId].solids;
@@ -379,23 +379,23 @@ class Solid {
                 },
                 mirror: (target, point, normal) => {
                     return this.resolve(async ([rTarget]) => {
-                        return solidAPI.mirror(drawingId, rTarget, makeNbrVec(point), makeNbrEuler(normal));
+                        return solidAPI.mirror(rTarget, makeNbrVec(point), makeNbrEuler(normal));
                     }, target);
                 },
                 moveTo: (target, position) => {
                     return this.resolve(async ([rTarget]) => {
-                        return solidAPI.moveTo(drawingId, rTarget, makeNbrVec(position));
+                        return solidAPI.moveTo(rTarget, makeNbrVec(position));
                     }, target);
                 },
                 offset: (target, offsetDistance) => {
                     return this.resolve(async ([rTarget]) => {
-                        return solidAPI.offset(drawingId, rTarget, offsetDistance);
+                        return solidAPI.offset(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);
+                        const breps = await solidAPI.pick(rTarget, type, ...pts);
                         if (breps !== null) {
                             return Array.isArray(breps) ? breps : [breps];
                         }
@@ -405,48 +405,48 @@ class Solid {
                     return this.resolve(async () => {
                         if (isShape(region)) {
                             const curveArray = makeCCData(region.curves);
-                            return solidAPI.createRevolveRegion(drawingId, makeNbrVec(position), makeNbrVec(direction), angle, curveArray);
+                            return solidAPI.createRevolveRegion(makeNbrVec(position), makeNbrVec(direction), angle, curveArray);
                         }
                         else {
-                            return solidAPI.createRevolve(drawingId, makeNbrVec(position), makeNbrVec(direction), (angle / Math.PI) * 180, region.points, region.bulges);
+                            return solidAPI.createRevolve(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));
+                        return solidAPI.rotateTo(rTarget, makeNbrEuler(point));
                     }, target);
                 },
                 save: () => {
                     return this.resolve(async () => {
-                        return solidAPI.save(drawingId, 'ofb');
+                        return solidAPI.save('ofb');
                     });
                 },
                 scale: (target, pointOrFactor) => {
                     return this.resolve(async ([rTarget]) => {
                         const lPointOrFactor = typeof pointOrFactor === 'number' ? pointOrFactor : makeNbrVec(pointOrFactor);
-                        return solidAPI.scale(drawingId, rTarget, lPointOrFactor);
+                        return solidAPI.scale(rTarget, lPointOrFactor);
                     }, target);
                 },
                 setFacetingParams: (distanceTol, angleTol) => {
                     return this.resolve(async () => {
-                        return classcad_1.ccAPI.common.setFacetingParameters(drawingId, distanceTol, angleTol);
+                        return commonAPI.setFacetingParameters(distanceTol, angleTol);
                     });
                 },
                 slice: (target, point, normal) => {
                     return this.resolve(async ([rTarget]) => {
-                        return solidAPI.slice(drawingId, rTarget, makeNbrVec(point), makeNbrVec(normal));
+                        return solidAPI.slice(rTarget, makeNbrVec(point), makeNbrVec(normal));
                     }, target);
                 },
                 sphere: (radius) => {
                     return this.resolve(async () => {
-                        return solidAPI.createSphere(drawingId, radius);
+                        return solidAPI.createSphere(radius);
                     });
                 },
                 subtract: (solidId, keepSolid, ...bodies) => {
                     return this.resolve(async ([rSolidId, ...rBodies]) => {
                         for (const rBody of rBodies) {
-                            solidAPI.subtract(drawingId, rSolidId, keepSolid, rBody);
+                            solidAPI.subtract(rSolidId, keepSolid, rBody);
                         }
                         return rSolidId;
                     }, solidId, ...bodies);
@@ -454,7 +454,7 @@ class Solid {
                 union: (solidId, keepSolid, ...bodies) => {
                     return this.resolve(async ([rSolidId, ...rBodies]) => {
                         for (const rBody of rBodies) {
-                            solidAPI.union(drawingId, rSolidId, keepSolid, rBody);
+                            solidAPI.union(rSolidId, keepSolid, rBody);
                         }
                         return rSolidId;
                     }, solidId, ...bodies);