@buerli.io/headless 0.2.0-beta.1 → 0.2.1

package/build/solid.d.ts

@@ -41,7 +41,7 @@ export declare type ApiNoHistory = {
      * api.clearSolids()
      * @image // tbd
      */
-    clearSolids: () => ID;
+    clearSolids: () => Promise<void>;
     /**
      * Clears the target solid in the drawing.
      * @param solidId id of the solid to be deleted
@@ -54,7 +54,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh( geom, new THREE.MeshStandardMaterial({}))
      * @image // tbd
      */
-    clearSolid: (solidId: VID) => ID;
+    clearSolid: (solidId: VID) => Promise<void>;
     /**
      * Creates a simple cone.
      * @param height height of the cone (z-axis)
@@ -116,7 +116,7 @@ export declare type ApiNoHistory = {
     cylinder: (height: number, diameter: number) => ID;
     /**
      * Returns all adjacent edges of a face or vertex
-     * @param target face or vertex id to get the adjacent edges from
+     * @param breps face or vertex ids to get the adjacent edges from
      * @example
      * // Returns all edges from the top surface of box and adds a fillet on them
      * const boxId = api.box(10, 25, 15)
@@ -127,7 +127,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/edgeLoops.jpg
      */
-    edgeLoops: (target: VIDs) => IDs;
+    edgeLoops: (breps: VIDs) => IDs;
     /**
      * Writes the current solid or specific solids to a stream in stp data format
      * and returns the data.
@@ -157,7 +157,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/extendSolidAtPlane.jpg
      */
-    extendSolidAtPlane: (target: VID, point: Vec, normal: Vec, distance: number) => ID;
+    extendSolidAtPlane: (target: VID, point: Vec, normal: Vec, distance: number) => Promise<void>;
     /**
      * Creates an extrusion.
      * @param height height of extrusion
@@ -244,7 +244,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/mirror.jpg
      */
-    mirror: (solidId: VID, point: Vec, normal: Vec) => ID;
+    mirror: (solidId: VID, point: Vec, normal: Vec) => Promise<void>;
     /**
      * Moves the solid to the given position.
      * @param solidId id of the solid which will be moved
@@ -259,7 +259,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/moveTo.jpg
      */
-    moveTo: (solidId: VID, position: Vec) => ID;
+    moveTo: (solidId: VID, position: Vec) => Promise<void>;
     /**
      * Creates an offset of the solid.
      * @param solidId solid which becomes an offset
@@ -287,12 +287,12 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/pick.jpg
      */
-    pick: (solidId: VID, type: string, ...points: Vec[]) => IDs;
+    pick: (solidId: VID, type: 'vertex' | 'edge' | 'face', ...points: Vec[]) => IDs;
     /**
      * Revolves the given region.
      * @param position position of rotation axis
      * @param direction direction of rotation axis
-     * @param angle angle of rotation
+     * @param angle angle of rotation in rad
      * @param region region which will be revolved, defined by Polyline or THREE.Shape
      * @example
      * // Creates a closed polyline from three points and revolves it
@@ -318,7 +318,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/rotateTo.jpg
      */
-    rotateTo: (solidId: VID, rotationVec: Vec) => ID;
+    rotateTo: (solidId: VID, rotationVec: Vec) => Promise<void>;
     /**
      * Writes the current drawing as native file format to a stream and returns the data.
      * Native file is 'of1', for 'stp' file format use export method.
@@ -348,15 +348,15 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/scale.jpg
      */
-    scale: (solidId: VID, vectorOrFactor: Vec | number) => ID;
+    scale: (solidId: VID, vectorOrFactor: Vec | number) => Promise<void>;
     /**
      * Sets the faceting parameters of graphic objects. This defines how detailed solids will be displayed.
      * @param distanceTol tolerated distance between theoretic and tesselated arc
      * @param angleTol tolerated angle between normal vectors of faces which build an arc
      * @example
      * // Creates a cylinder with low tessellation
-     * const cylinderId = api.cylinder(50, 20)
      * api.setFacetingParams(0.5, 0)
+     * const cylinderId = api.cylinder(50, 20)
      * const geom = await api.createBufferGeometry(cylinderId)
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/setFacetingParams.jpg
@@ -375,7 +375,7 @@ export declare type ApiNoHistory = {
      * const mesh = new THREE.Mesh(geom, new THREE.MeshStandardMaterial({}))
      * @image /doc/assets/solid/slice.jpg
      */
-    slice: (solidId: VID, point: Vec, normal: Vec) => ID;
+    slice: (solidId: VID, point: Vec, normal: Vec) => Promise<void>;
     /**
      * Creates a simple sphere.
      * @param radius radius of the sphere
@@ -435,6 +435,7 @@ export default class CAD {
     private drawingId;
     queue: Promise<number>;
     constructor();
+    resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;
     init(callback: (api: ApiNoHistory) => void): () => Promise<void>;
     destroy(): void;
 }

package/build/solid.js

@@ -3,34 +3,19 @@ import { ccAPI } from '@buerli.io/classcad';
 import { api, getDrawing } from '@buerli.io/core';
 import { Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
 import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUtils';
+const solidAPI = ccAPI.solid;
 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 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 toCCNbrVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
 const toArray = (v) => (Array.isArray(v) ? v : v.toArray());
 const toEuler = (v) => toArray(v);
 const makeVec = (v) => toCCVec(toArray(v));
+const makeNbrVec = (v) => toCCNbrVec(toArray(v));
 const makeEuler = (v) => toCCVec(toEuler(v));
-const makeBoolean = (instance, drawingId, type) => (target, keepSolid, ...bodies) => {
-    for (const body of bodies)
-        exec(instance, drawingId, 'Solid', type, undefined, false, target, keepSolid, body);
-    return target;
-};
+const makeNbrEuler = (v) => toCCNbrVec(toEuler(v));
 /**
  * Returns the entity of solid from structure tree
  * @param drawingId Id of current drawing
@@ -173,7 +158,7 @@ const makeCCData = (curves) => {
             // [...points]
             case 'SplineCurve':
                 return [curve.type, curve.points.map((point) => point.toArray())];
-            // [pA, radii, angles, clockwise, rotation]
+            // [pA, radius, angles, clockwise, rotation]
             case 'EllipseCurve':
             case 'ArcCurve':
                 const { aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation } = curve;
@@ -196,19 +181,42 @@ export default class CAD {
         this.queue = Promise.resolve(0);
         this.queue = Promise.resolve(0);
     }
+    resolve(callback, ...args) {
+        return (this.queue = this.queue.then(() => Promise.all(args).then(callback)));
+    }
     init(callback) {
         const promise = new Promise(async (resolve, reject) => {
             const drawingId = await ccAPI.base.createCCDrawing('solid');
             if (!drawingId)
                 throw new Error('Drawing could not be created');
             this.drawingId = drawingId;
-            await exec(this, drawingId, 'Solid', 'Init', undefined, false);
+            await solidAPI.init(drawingId);
             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),
+                box: (length, width, height) => {
+                    return this.resolve(async () => {
+                        return solidAPI.createBox(drawingId, length, width, height);
+                    });
+                },
+                clearSolids: () => {
+                    return this.resolve(async () => {
+                        return solidAPI.clearSolids(drawingId);
+                    });
+                },
+                clearSolid: (target) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.clearSolid(drawingId, rTarget);
+                    }, target);
+                },
+                cone: (length, diameter1, diameter2) => {
+                    return this.resolve(async () => {
+                        return solidAPI.createCone(drawingId, length, diameter1, diameter2);
+                    });
+                },
+                copy: (target) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.copy(drawingId, rTarget);
+                    }, target);
+                },
                 createBufferGeometry: async (solid) => {
                     await this.queue;
                     this.queue = Promise.resolve(0);
@@ -227,6 +235,7 @@ export default class CAD {
                     const entity = await getEntity(drawingId, rSolid);
                     const group = new Scene();
                     group.userData = { id: rSolid };
+                    group.name = 'Solid';
                     if (entity != null) {
                         for (const mesh of entity.meshes) {
                             group.add(new Mesh(mesh.geometry, new MeshStandardMaterial({
@@ -238,78 +247,150 @@ export default class CAD {
                     }
                     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),
+                cylinder: (length, diameter) => {
+                    return this.resolve(async () => {
+                        return solidAPI.createCylinder(drawingId, length, diameter);
+                    });
+                },
+                edgeLoops: (breps) => {
+                    return this.resolve(async ([rBreps]) => {
+                        return solidAPI.edgeLoops(drawingId, rBreps);
+                    }, breps);
+                },
+                export: (solidIds) => {
+                    return this.resolve(async ([rSolidIds]) => {
+                        return solidAPI.export(drawingId, 'stp', rSolidIds);
+                    }, solidIds);
+                },
+                extendSolidAtPlane: (target, point, normal, distance) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.solidExtendAtPlane(drawingId, rTarget, makeNbrVec(point), makeNbrVec(normal), distance);
+                    }, target);
+                },
                 extrude: (height, region) => {
-                    if (region instanceof 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);
-                    }
+                    return this.resolve(async () => {
+                        if (region instanceof Shape) {
+                            const curveArray = makeCCData(region.curves);
+                            return solidAPI.createExtrudeRegion(drawingId, makeNbrVec(height), curveArray);
+                        }
+                        else {
+                            return solidAPI.createExtrude(drawingId, makeNbrVec(height), region.points, region.bulges);
+                        }
+                    });
                 },
-                fillet: (radius, edges) => 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 = getDrawing(drawingId);
-                        const solids = drawing.structure.tree[id].solids;
-                        if (solids !== undefined) {
-                            return solids.map(innerId => drawing.graphic.containers[innerId].owner);
+                fillet: (radius, edges) => {
+                    return this.resolve(async ([rEdges]) => {
+                        return solidAPI.createFillet(drawingId, radius, rEdges);
+                    }, edges);
+                },
+                import: (data) => {
+                    return this.resolve(async () => {
+                        return solidAPI.import(drawingId, data, 'stp');
+                    });
+                },
+                intersect: (solidId, keepSolid, ...bodies) => {
+                    return this.resolve(async ([rSolidId, ...rBodies]) => {
+                        for (const rBody of rBodies) {
+                            solidAPI.intersect(drawingId, rSolidId, keepSolid, rBody);
                         }
-                    }
-                    return [];
-                }),
-                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 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);
-                    }
+                        return rSolidId;
+                    }, solidId, ...bodies);
                 },
-                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;
+                load: (data) => {
+                    return this.resolve(async () => {
+                        const productId = await solidAPI.load(drawingId, data, 'of1', true);
+                        if (productId !== null) {
+                            const drawing = getDrawing(drawingId);
+                            const solids = drawing.structure.tree[productId].solids;
+                            if (solids !== undefined) {
+                                return solids.map(innerId => drawing.graphic.containers[innerId].owner);
+                            }
                         }
-                    }
-                }),
+                        return [];
+                    });
+                },
+                mirror: (target, point, normal) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.mirror(drawingId, rTarget, makeNbrVec(point), makeNbrEuler(normal));
+                    }, target);
+                },
+                moveTo: (target, position) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.moveTo(drawingId, rTarget, makeNbrVec(position));
+                    }, target);
+                },
+                offset: (target, offsetDistance) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.offset(drawingId, rTarget, offsetDistance);
+                    }, target);
+                },
+                pick: (target, type, ...points) => {
+                    return this.resolve(async ([rTarget]) => {
+                        const pts = points.map(pt => makeNbrVec(pt));
+                        const breps = await solidAPI.pick(drawingId, rTarget, type, ...pts);
+                        if (breps !== null) {
+                            return Array.isArray(breps) ? breps : [breps];
+                        }
+                    }, target);
+                },
+                revolve: (position, direction, angle, region) => {
+                    return this.resolve(async () => {
+                        if (region instanceof Shape) {
+                            const curveArray = makeCCData(region.curves);
+                            return solidAPI.createRevolveRegion(drawingId, makeNbrVec(position), makeNbrVec(direction), angle, curveArray);
+                        }
+                        else {
+                            return solidAPI.createRevolve(drawingId, makeNbrVec(position), makeNbrVec(direction), (angle / Math.PI) * 180, region.points, region.bulges);
+                        }
+                    });
+                },
+                rotateTo: (target, point) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.rotateTo(drawingId, rTarget, makeNbrEuler(point));
+                    }, target);
+                },
+                save: () => {
+                    return this.resolve(async () => {
+                        return solidAPI.save(drawingId, 'of1');
+                    });
+                },
                 scale: (target, pointOrFactor) => {
-                    const lPointOrFactor = typeof pointOrFactor === 'number' ? pointOrFactor : makeVec(pointOrFactor);
-                    return exec(this, drawingId, 'Solid', 'Scale', undefined, false, target, lPointOrFactor);
+                    return this.resolve(async ([rTarget]) => {
+                        const lPointOrFactor = typeof pointOrFactor === 'number' ? pointOrFactor : makeNbrVec(pointOrFactor);
+                        return solidAPI.scale(drawingId, rTarget, lPointOrFactor);
+                    }, target);
+                },
+                setFacetingParams: (distanceTol, angleTol) => {
+                    return this.resolve(async () => {
+                        return ccAPI.common.setFacetingParameters(drawingId, distanceTol, angleTol);
+                    });
+                },
+                slice: (target, point, normal) => {
+                    return this.resolve(async ([rTarget]) => {
+                        return solidAPI.slice(drawingId, rTarget, makeNbrVec(point), makeNbrVec(normal));
+                    }, target);
+                },
+                sphere: (radius) => {
+                    return this.resolve(async () => {
+                        return solidAPI.createSphere(drawingId, radius);
+                    });
+                },
+                subtract: (solidId, keepSolid, ...bodies) => {
+                    return this.resolve(async ([rSolidId, ...rBodies]) => {
+                        for (const rBody of rBodies) {
+                            solidAPI.subtract(drawingId, rSolidId, keepSolid, rBody);
+                        }
+                        return rSolidId;
+                    }, solidId, ...bodies);
+                },
+                union: (solidId, keepSolid, ...bodies) => {
+                    return this.resolve(async ([rSolidId, ...rBodies]) => {
+                        for (const rBody of rBodies) {
+                            solidAPI.union(drawingId, rSolidId, keepSolid, rBody);
+                        }
+                        return rSolidId;
+                    }, solidId, ...bodies);
                 },
-                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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.1",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
@@ -29,6 +29,6 @@
     "three": ">=0.138"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.2.0-beta.1"
+    "@buerli.io/classcad": "0.2.1"
   }
 }