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

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 { createApi, BuerliCadFacade } 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 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 } = createApi(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,7 +1,9 @@
-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';
 /**
+ * @deprecated replaced by @see BuerliCadFacade in buerli.io/classcad
+ *
  * History based modeling is similar to solid modeling, but it is non-destructive and
  * parametric. You can move back and forth in the modeling history and create feature
  * expressions which you can alter at a later time, prompting your model to re-calculate.
@@ -1515,6 +1517,24 @@ export declare type ApiHistory = {
             value: number | string;
         }[];
     }[]) => Promise<boolean>;
+    /**
+     * Renames existing expressions.
+     * @param partId id or identifier of part to rename expressions from
+     * @param members name of members to rename
+     * @example
+     * // Renames an expression from part's expression set
+     * const part = api.createPart('Part')
+     * api.createExpressions(part, { name: 'width', value: 20 }, { name: 'h', value: 40 })
+     * api.renameExpressions(part, [{ name: 'h', newName: 'height'}])
+     * await api.box(part, [], 20, 20, 'ExpressionSet.height')
+     * const geoms = await api.createBufferGeometry(part)
+     * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return true or false, depending on whether renaming the expressions was successful or not
+     */
+    renameExpressions: (partId: VID | ObjectIdent, members: {
+        name: string;
+        newName: string;
+    }[]) => Promise<boolean>;
     /**
      * Creates a mirror operation.
      * Mirrors the entities of an operation at the position of the plane reference
@@ -1759,11 +1779,11 @@ export declare type LinearPatternConstraintType = {
     /** distance between copies over the first direction (set by z-axis of mate1) */
     firstDirDistance: number | string;
     /** second mate constraint (z-axis sets the second direction) */
-    mate2: MateParam;
+    mate2?: MateParam;
     /** number of copies over the second direction (set by z-axis of mate2) */
-    secondDirInstanceCount: number | string;
+    secondDirInstanceCount?: number | string;
     /** number of copies over the second direction (set by z-axis of mate2) */
-    secondDirDistance: number | string;
+    secondDirDistance?: number | string;
 };
 export declare type CircularPatternConstraintType = {
     /** id of the constraint */

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,6 +1,9 @@
-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';
 /**
+ * @deprecated replaced by @see BuerliCadFacade in buerli.io/classcad
+ *
  * A simple and intuitive javascript based api that incorporates solid operations like
  * shapes, booleans (unions, subtracts, intersections), extrusions, revolves, blends,
  * chamfers, slices, arrays, patterns, offsets, etc. The api is compatible with THREEJS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.13.1-beta.1",
+  "version": "0.13.1-beta.10",
   "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.1",
+    "@buerli.io/classcad": "0.13.1-beta.10",
     "flat-promise": "^1.0.3"
   }
 }