@buerli.io/headless 0.13.1-beta.4 → 0.13.1-beta.7.apiversion

package/build/esm/index.js

@@ -4,5 +4,5 @@ export { Solid, solid, History, history, createPolyline };
 // Re-export types form @buerli.io/classcad for easier usage
 export { init, BooleanOperationType, ChamferType, DataType, FlipType, ReorientedType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, OrientationType, ExtrusionType, SVGModusType, } from '@buerli.io/classcad';
 // Re-export types form @buerli.io/core for easier usage
-export { GraphicType, ContainerType, MeshTypes, EdgeTypes, CurveTypes, EntityTypes, PointTypes } from '@buerli.io/core';
+export { GraphicType, ContainerType, MeshTypes, EdgeTypes, CurveTypes, EntityTypes, PointTypes, } from '@buerli.io/classcad';
 //#endregion Re-export type definitions

package/build/esm/solid.js

@@ -6,13 +6,12 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     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 as ccApi, Connection } from '@buerli.io/classcad';
 import { api, getDrawing } from '@buerli.io/core';
 import { Group, Mesh, MeshStandardMaterial, Scene } from 'three';
 import { mergeBufferGeometries } from 'three-stdlib';
 import { getDifferentColoredMeshesFromEntity } from './utils/meshes';
 const isShape = (entity) => entity && entity.type === 'Shape';
-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());
@@ -195,46 +194,47 @@ export class Solid {
     }
     init(callback) {
         const promise = new Promise(async (resolve, reject) => {
-            const drawingId = await ccAPI.base.createCCDrawing('solid');
+            const drawingId = await Connection.create('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 } = ccApi(drawingId).v0;
+            await solidAPI.init();
             const publicApi = {
                 getDrawingId: () => drawingId,
                 getDrawing: () => getDrawing(drawingId),
                 getState: () => api.getState(),
-                setFacetingParameters: (distanceTol, angleTol) => this.resolve(async () => 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 ccAPI.baseModeler.requestVisualisationOfObject(drawingId, rSolid);
+                    await baseModelerAPI.requestVisualisationOfObject(rSolid);
                     const entity = await getEntity(drawingId, rSolid);
                     if (entity != null) {
                         return mergeBufferGeometries(entity.meshes.map(m => m.geometry));
@@ -253,7 +253,7 @@ export 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 ccAPI.baseModeler.requestVisualisationOfObject(drawingId, _solid);
+                            await baseModelerAPI.requestVisualisationOfObject(_solid);
                             const cDrawing = getDrawing(drawingId);
                             const solidObject = cDrawing.structure.tree[_solid];
                             if (solidObject) {
@@ -313,56 +313,56 @@ export 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 = getDrawing(drawingId);
                             const solids = drawing.structure.tree[productId].solids;
@@ -375,23 +375,23 @@ export 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];
                         }
@@ -401,48 +401,48 @@ export 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 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);
@@ -450,7 +450,7 @@ export 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);

package/build/types/history.d.ts

@@ -1,5 +1,5 @@
-import { BooleanOperationType, ChamferType, FlipType, ReorientedType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, ExtrusionType, WorkGeomType, SVGModusType, LimitsParam, DimensionParam, LimitedValue } from '@buerli.io/classcad';
-import { DrawingID, ObjectIdent, ObjectID, GraphicType, InteractionInfo, GeometryElement, DrawingState, BuerliState } from '@buerli.io/core';
+import { BooleanOperationType, ChamferType, FlipType, ReorientedType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, ExtrusionType, WorkGeomType, SVGModusType, LimitsParam, DimensionParam, LimitedValue, GraphicType, ObjectID, ObjectIdent } from '@buerli.io/classcad';
+import { DrawingID, InteractionInfo, GeometryElement, DrawingState, BuerliState } from '@buerli.io/core';
 import { BufferGeometry, Material, Object3D, Scene } from 'three';
 /**
  * History based modeling is similar to solid modeling, but it is non-destructive and

package/build/types/index.d.ts

@@ -2,7 +2,7 @@ import { History, history } from './history';
 import { Solid, solid, createPolyline } from './solid';
 export { Solid, solid, History, history, createPolyline };
 export { init, BooleanOperationType, ChamferType, DataType, FlipType, ReorientedType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, OrientationType, ExtrusionType, SVGModusType, } from '@buerli.io/classcad';
-export { GraphicType, ContainerType, MeshTypes, EdgeTypes, CurveTypes, EntityTypes, PointTypes } from '@buerli.io/core';
+export { GraphicType, ContainerType, MeshTypes, EdgeTypes, CurveTypes, EntityTypes, PointTypes, } from '@buerli.io/classcad';
 /**
  * Because babel typescript tools can not handle the type definitions
  * in an other way, they have to be re-exported as you can see in this code region.

package/build/types/solid.d.ts

@@ -1,4 +1,5 @@
-import { BuerliState, DrawingID, DrawingState, ObjectID } from '@buerli.io/core';
+import { ObjectID } from '@buerli.io/classcad';
+import { BuerliState, DrawingID, DrawingState } from '@buerli.io/core';
 import { BufferGeometry, Scene, Vector3 } from 'three';
 /**
  * A simple and intuitive javascript based api that incorporates solid operations like

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.13.1-beta.4",
+  "version": "0.13.1-beta.7.apiversion",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
@@ -32,7 +32,7 @@
     "three-stdlib": ">=2.11.0"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.13.1-beta.4",
+    "@buerli.io/classcad": "0.13.1-beta.7.apiversion",
     "flat-promise": "^1.0.3"
   }
 }