@buerli.io/headless 0.0.36-beta.0 → 0.1.0

package/build/history.d.ts

@@ -65,6 +65,150 @@ export declare type ApiHistory = {
         transformation: Transform;
         name?: string;
     }[]) => IDs;
+    /**
+     * Adds a dimension to the product in the 3D view
+     * @param dimension dimension to be added to a product
+     * @example
+     * // Get the current product
+     * const productId = await api.getCurrentProduct()
+     *
+     * // Create a dimension
+     * const dimension: DimensionType = {
+     *   productId: productId,
+     *   dimParam: {
+     *     dimType: 'LinearDimension',
+     *     dimLabel: 'Breite = ',
+     *     dimStartPos: { x: 0, y: 0, z: 0 },
+     *     dimEndPos: { x: 100, y: 0, z: 0 },
+     *     dimTextPos: { x: 50, y: -10, z: 0 },
+     *     dimTextAngle: 0,
+     *     dimOrientation: 'Horizontal',
+     *   },
+     *   dxfView: 'Top',
+     * }
+     *
+     * // Add the dimension
+     * const dimensionId = await api.addDimension(dimension)
+     * @image // tbd
+     * @return id of the added dimension
+     */
+    addDimension: (dimension: DimensionType) => ID;
+    /**
+     * Adds multiple dimensions to products in the 3D view
+     * @param dimensions dimensions to be added to products
+     * @example
+     * // Get the current product
+     * const productId = await api.getCurrentProduct()
+     *
+     * // Create dimensions
+     * const dimension1: DimensionType = {
+     *   productId: productId,
+     *   dimParam: {
+     *     dimType: 'LinearDimension',
+     *     dimLabel: 'Breite = ',
+     *     dimStartPos: { x: 0, y: 0, z: 0 },
+     *     dimEndPos: { x: 100, y: 0, z: 0 },
+     *     dimTextPos: { x: 50, y: -10, z: 0 },
+     *     dimTextAngle: 0,
+     *     dimOrientation: 'Horizontal',
+     *   },
+     *   dxfView: 'Top',
+     * }
+     *
+     * const dimension2: DimensionType = {
+     *   productId: productId,
+     *   dimParam: {
+     *     dimType: 'LinearDimension',
+     *     dimLabel: 'Laenge = ',
+     *     dimStartPos: { x: 0, y: 0, z: 0 },
+     *     dimEndPos: { x: 0, y: 100, z: 0 },
+     *     dimTextPos: { x: 10, y: 50, z: 0 },
+     *     dimTextAngle: 0,
+     *     dimOrientation: 'Horizontal',
+     *   },
+     *   dxfView: 'Top',
+     * }
+     *
+     * // Add the dimensions
+     * const dimensionIds = await api.addDimensions(dimension1, dimension2)
+     * @image // tbd
+     * @return array of ids of the added dimensions
+     */
+    addDimensions: (...dimensions: {
+        productId: number;
+        dimParam: {
+            dimType: DimTypes;
+            dimName?: string;
+            dimLabel: string;
+            dimValue?: number | null;
+            dimStartPos: PointMemValue;
+            dimEndPos: PointMemValue;
+            dimTextPos: PointMemValue;
+            dimTextAngle: number;
+            dimOrientation: OrientationTypes;
+            dimColor?: number;
+            dimLayer?: string;
+        };
+        dxfView: ViewTypes;
+    }[]) => IDs;
+    /**
+     * Creates different 2D views, depending on the given view types, in the given product.
+     * @param productId id of the product where the view will be created in
+     * @param viewTypes array of view types. E.g. 'Top', 'Front', 'Iso', ...
+     * @example
+     * // Optionally add dimensions to the product, see addDimension() or addDimensions()
+     * await api.addDimensions(...)
+     *
+     * // Create the wanted views
+     * await api.create2DViews(productId, ['Top', 'Right_90°', 'Iso'])
+     * @image // tbd
+     */
+    create2DViews: (productId: VID, viewTypes: ViewTypes[]) => IDs;
+    /**
+     * This method returns the boundary box of the given views.
+     * @param productId id of the product from where the boundary box will returned
+     * @param viewTypes array of view types. E.g. 'Top', 'Front', 'Iso', ...
+     * @example
+     * // After views have been created, see create2DViews(), you can get boundary boxes
+     * const bbs = await api.getBoundaryBoxFromViews(productId, ['Top', 'Right_90°', 'Iso'])
+     *
+     * // Returns for each view a min and max point
+     * console.info(bbs) // [[{x: -105, y: -89, z: 0}, {x: 105, y: 55, z: 0}], [...], [...]]
+     * @image // tbd
+     */
+    getBoundaryBoxFromViews: (productId: VID, viewTypes?: ViewTypes[]) => Promise<[PointMemValue, PointMemValue][]>;
+    /**
+     * @param productId id of the product where the views will be placed in
+     * @param viewPositions array of objects, containing the viewType and a vector which defines the moving vector of the given view
+     * @example
+     * // After the views have been created, see create2DViews(), you can place them relatively to origin {0,0,0}
+     * await api.place2DViews(productId, [
+     *   { viewType: 'Iso', vector: { x: 500, y: 500, z: 0 } },
+     *   { viewType: 'Right_90°', vector: { x: 500, y: 0, z: 0 } },
+     * ])
+     * @image // tbd
+     */
+    place2DViews: (productId: VID, viewPositions: {
+        viewType: ViewTypes;
+        vector: PointMemValue;
+    }[]) => Promise<void>;
+    /**
+     * @param productId id of the product where the views exist for export
+     * @example
+     * // After creating and placing the views, see place2DViews(), you can export them
+     * // You will get the dxf stream back
+     * await api.exportDXF(productId)
+     * @image // tbd
+     */
+    exportDXF: (productId: VID) => Promise<Uint8Array | null>;
+    /**
+     * @param dimensionsIds ids of the dimensions to be removed
+     * @example
+     * // You can remove existing dimensions
+     * await api.removeDimensions(dimensionIds)
+     * @image // tbd
+     */
+    removeDimensions: (dimensionIds: number[]) => Promise<void>;
     /**
      * Creates a boolean operation.
      * @param partId id of the part where the operation will be created on
@@ -603,6 +747,43 @@ export declare type ApiHistory = {
      * @image // tbd
      */
     getAssemblyNode: (refId: VID, nodeName?: string) => IDs;
+    /**
+     * Returns the id of the current product
+     * @example // tbd
+     * @image // tbd
+     */
+    getCurrentProduct: () => ID;
+    /**
+     * Sets the node with refId to the new current node
+     *
+     * @param refId Reference id of the node to set as the current
+     * @example // tbd
+     * @image // tbd
+     */
+    setCurrentNode: (refId: VID) => void;
+    /**
+     * Sets the product with productId to the new current product
+     *
+     * @param productId Id of the product to set as the current
+     * @example // tbd
+     * @image // tbd
+     */
+    setCurrentProduct: (productId: VID) => void;
+    /**
+     * Returns the id of the current node
+     * @example // tbd
+     * @image // tbd
+     */
+    getCurrentNode: () => ID;
+    /**
+     * Returns the coordinate system of the node with the
+     * given refId. Where the node is an instance in the expanded tree of any product template
+     *
+     * @param refId Reference id of the node to get the coordinate system from
+     * @example // tbd
+     * @image // tbd
+     */
+    getCoordSysFromNode: (refId: VID) => Promise<number[][]>;
     /**
      * Returns the part with given name from part container.
      * If partName is empty, all parts from part container will be returned.
@@ -719,6 +900,16 @@ export declare type ApiHistory = {
         referenceId: number;
         ownerId: number;
     }[]) => Promise<void>;
+    /**
+     * Transforms the node with referenceId with the given transformation
+     *
+     * @param referenceId id of the node to transform
+     * @param ownerId id of the owner (parent) of node we want to transform
+     * @param transformation array of three vectors [origin, xAxis, yAxis]
+     * @example // tbd
+     * @image // tbd
+     */
+    transformNode: (referenceId: VID, ownerId: VID, transformation: Transform) => Promise<void>;
     /**
      * Translates a feature along a given axis.
      * @param partId id ot the part where features will be translated
@@ -768,16 +959,32 @@ export declare type ApiHistory = {
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
      * @image // tbd
+     * @returns true, if updating expressions was successfull
      */
     setExpressions: (partId: VID, ...members: {
         name: string;
         value: number | PointMemValue | string;
-    }[]) => Promise<void>;
+    }[]) => Promise<boolean>;
+    /**
+     * Updates multiple expression sets in different parts at once
+     *
+     * @param exprSets array of expression objects containing the part id and the expression to set
+     * @example // tbd
+     * @image // tbd
+     * @returns true, if updating expressions in all expression sets was successfull
+     */
+    setExpressionSets: (...exprSets: {
+        partId: number;
+        members: {
+            name: string;
+            value: number | PointMemValue | string;
+        }[];
+    }[]) => Promise<boolean>;
 };
 export default class CAD {
     private drawingId;
     queue: Promise<number>;
-    constructor(url: string);
+    constructor();
     resolve(callback: (...results: any) => Promise<any>, ...args: any[]): Promise<any>;
     init(callback: (api: ApiHistory) => void): () => Promise<void>;
     destroy(): void;
@@ -799,6 +1006,26 @@ declare type ChamferTypes = 'Equal_Distance' | 'Two_Distances' | 'Distance_And_A
 declare type PickTypes = 'vertex' | 'edge' | 'face';
 declare type DataTypes = 'of1' | 'stp' | 'step';
 declare type SupportedImportFormats = 'STEP' | 'STP' | 'SAT' | 'IWB' | 'IWP' | 'IWC' | 'IGS' | 'STL' | 'DXF' | 'DWG';
+declare type DimTypes = 'LinearDimension';
+declare type ViewTypes = 'Top' | 'Front' | 'Right' | 'Left' | 'Bottom' | 'Right_90°' | 'Left_90°' | 'Back' | 'Iso';
+export declare type OrientationTypes = 'Horizontal' | 'Vertical';
+export declare type DimensionType = {
+    productId: number;
+    dimParam: {
+        dimType: DimTypes;
+        dimName?: string;
+        dimLabel: string;
+        dimValue?: number | null;
+        dimStartPos: PointMemValue;
+        dimEndPos: PointMemValue;
+        dimTextPos: PointMemValue;
+        dimTextAngle: number;
+        dimOrientation: OrientationTypes;
+        dimColor?: number;
+        dimLayer?: string;
+    };
+    dxfView: ViewTypes;
+};
 /**
  * Information about constraint.
  * [

package/build/history.js

@@ -1,7 +1,7 @@
 /* eslint-disable max-lines */
-import { BooleanOperationType, ccAPI, CCClasses, ccUtils, ChamferType, DataType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType } from '@buerli.io/classcad';
-import { api, getDrawing, init, MathUtils, } from '@buerli.io/core';
-import { Group, Mesh, MeshStandardMaterial, Scene } from 'three';
+import { BooleanOperationType, ccAPI, CCClasses, ccUtils, ChamferType, DataType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, OrientationType, } from '@buerli.io/classcad';
+import { api, getDrawing, MathUtils, } from '@buerli.io/core';
+import { Group, Mesh, MeshStandardMaterial, Scene, Vector3 } from 'three';
 import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUtils';
 const featureAPI = ccAPI.feature;
 let BufferGeometryUtils = BufferGeometryUtils_;
@@ -140,6 +140,68 @@ const getWPTType = (type) => {
             break;
     }
 };
+const getViewType = (type) => {
+    switch (type) {
+        case 'Top':
+            return ViewType.TOP;
+        case 'Front':
+            return ViewType.FRONT;
+        case 'Right':
+            return ViewType.RIGHT;
+        case 'Left':
+            return ViewType.LEFT;
+        case 'Bottom':
+            return ViewType.BOTTOM;
+        case 'Right_90°':
+            return ViewType.RIGHT_90;
+        case 'Left_90°':
+            return ViewType.LEFT_90;
+        case 'Back':
+            return ViewType.BACK;
+        case 'Iso':
+            return ViewType.ISO;
+        case undefined:
+            break;
+    }
+};
+const getOrientationType = (type) => {
+    switch (type) {
+        case 'Vertical':
+            return OrientationType.VERTICAL;
+        case 'Horizontal':
+            return OrientationType.HORIZONTAL;
+        case undefined:
+            break;
+    }
+};
+const getDimensionType = (type) => {
+    switch (type) {
+        case 'LinearDimension':
+            return CCClasses.CCLinearDimension;
+        case undefined:
+            break;
+    }
+};
+const getGlobalTransformation = (drawingId, ownerId, localTransformation) => {
+    const lT = localTransformation;
+    const coordSysOwner = ccUtils.assembly.getCoordSysFromNode(drawingId, ownerId);
+    if (coordSysOwner) {
+        const origin = [lT[0].x, lT[0].y, lT[0].z];
+        const xAxis = [lT[1].x, lT[1].y, lT[1].z];
+        const yAxis = [lT[2].x, lT[2].y, lT[2].z];
+        const zAxis = new Vector3().crossVectors(new Vector3(lT[1].x, lT[1].y, lT[1].z), new Vector3(lT[2].x, lT[2].y, lT[2].z));
+        const matrix = MathUtils.convertToMatrix4([origin, xAxis, yAxis, [zAxis.x, zAxis.y, zAxis.z]]);
+        const transformation = MathUtils.convertToMatrix4(coordSysOwner).clone().multiply(matrix);
+        const transformationCoords = MathUtils.convertToCoordinateSystem(transformation);
+        const tC = transformationCoords;
+        return [
+            { x: tC[0][0], y: tC[0][1], z: tC[0][2] },
+            { x: tC[1][0], y: tC[1][1], z: tC[1][2] },
+            { x: tC[2][0], y: tC[2][1], z: tC[2][2] },
+        ];
+    }
+    return undefined;
+};
 const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray) => {
     let cDrawing = getDrawing(drawingId);
     const tree = cDrawing.structure.tree;
@@ -244,14 +306,12 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
     }
 };
 export default class CAD {
-    constructor(url) {
+    constructor() {
         this.drawingId = null;
         this.queue = Promise.resolve(0);
         this.queue = Promise.resolve(0);
-        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) {
@@ -263,18 +323,117 @@ export default class CAD {
             const publicApi = {
                 addNode: (productId, ownerId, transformation, name) => {
                     return this.resolve(async ([rProductId, rOwnerId]) => {
-                        return ccAPI.assemblyBuilder.addNode(drawingId, rProductId, rOwnerId, transformation, name);
+                        const globalTransformation = getGlobalTransformation(drawingId, rOwnerId, transformation) || transformation;
+                        return ccAPI.assemblyBuilder.addNode(drawingId, rProductId, rOwnerId, globalTransformation, name);
                     }, productId, ownerId);
                 },
                 addNodes: (...nodes) => {
                     return this.resolve(async ([]) => {
                         const nodesToAdd = [];
                         nodes.forEach(node => {
-                            nodesToAdd.push([node.productId, node.ownerId, node.transformation, node.name]);
+                            const globalTransformation = getGlobalTransformation(drawingId, node.ownerId, node.transformation) || node.transformation;
+                            nodesToAdd.push([node.productId, node.ownerId, globalTransformation, node.name]);
                         });
                         return ccAPI.assemblyBuilder.addNodes(drawingId, nodesToAdd);
                     });
                 },
+                addDimension: (dim) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const orientation = getOrientationType(dim.dimParam.dimOrientation);
+                        const view = getViewType(dim.dxfView);
+                        const dimensionType = getDimensionType(dim.dimParam.dimType);
+                        if (orientation !== undefined && view !== undefined) {
+                            const dimParam = [
+                                rProductId,
+                                [
+                                    dimensionType || 'CC_LinearDimenion',
+                                    dim.dimParam.dimName || 'Dimension',
+                                    dim.dimParam.dimLabel,
+                                    dim.dimParam.dimValue || null,
+                                    dim.dimParam.dimStartPos,
+                                    dim.dimParam.dimEndPos,
+                                    dim.dimParam.dimTextPos,
+                                    dim.dimParam.dimTextAngle,
+                                    orientation,
+                                    dim.dimParam.dimColor || 256,
+                                    dim.dimParam.dimLayer || '2', // which layer makes sense as default?
+                                ],
+                                view,
+                            ];
+                            return ccAPI.drawing2D.addDimension(drawingId, dimParam);
+                        }
+                    }, dim.productId);
+                },
+                addDimensions: (...dimensions) => {
+                    return this.resolve(async ([]) => {
+                        const dimsToAdd = [];
+                        dimensions.forEach(dim => {
+                            const orientation = getOrientationType(dim.dimParam.dimOrientation);
+                            const view = getViewType(dim.dxfView);
+                            const dimensionType = getDimensionType(dim.dimParam.dimType);
+                            if (orientation !== undefined && view !== undefined) {
+                                dimsToAdd.push([
+                                    dim.productId,
+                                    [
+                                        dimensionType || 'CC_LinearDimenion',
+                                        dim.dimParam.dimName || 'Dimension',
+                                        dim.dimParam.dimLabel,
+                                        dim.dimParam.dimValue || null,
+                                        dim.dimParam.dimStartPos,
+                                        dim.dimParam.dimEndPos,
+                                        dim.dimParam.dimTextPos,
+                                        dim.dimParam.dimTextAngle,
+                                        orientation,
+                                        dim.dimParam.dimColor || 256,
+                                        dim.dimParam.dimLayer || '2', // which layer makes sense as default?
+                                    ],
+                                    view,
+                                ]);
+                            }
+                        });
+                        return ccAPI.drawing2D.addDimensions(drawingId, dimsToAdd);
+                    });
+                },
+                create2DViews: (productId, viewTypes) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const types = viewTypes.map(viewType => getViewType(viewType));
+                        const viewIds = await ccAPI.drawing2D.create2DViews(drawingId, rProductId, types);
+                        if (viewIds !== null) {
+                            await ccAPI.drawing2D.centerAllViews(drawingId, rProductId, types);
+                            return viewIds;
+                        }
+                        return null;
+                    }, productId);
+                },
+                getBoundaryBoxFromViews: (productId, viewTypes) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const types = viewTypes === null || viewTypes === void 0 ? void 0 : viewTypes.map(viewType => getViewType(viewType));
+                        const bbs = await ccAPI.drawing2D.getBoundaryBoxFromViews(drawingId, rProductId, types);
+                        return bbs;
+                    }, productId);
+                },
+                place2DViews: (productId, viewPositions) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const viewPositionParams = [];
+                        viewPositions.forEach(viewPos => {
+                            const type = getViewType(viewPos.viewType);
+                            if (type !== undefined) {
+                                viewPositionParams.push([type, viewPos.vector]);
+                            }
+                        });
+                        return ccAPI.drawing2D.place2DViews(drawingId, rProductId, viewPositionParams);
+                    }, productId);
+                },
+                exportDXF: (productId) => {
+                    return this.resolve(async ([rProductId]) => {
+                        return ccAPI.drawing2D.exportDXF(drawingId, rProductId);
+                    }, productId);
+                },
+                removeDimensions: (dimensionIds) => {
+                    return this.resolve(async () => {
+                        return ccAPI.drawing2D.removeDimensions(drawingId, dimensionIds);
+                    });
+                },
                 boolean: (partId, type, entities) => {
                     return this.resolve(async ([rPartId, ...rEntities]) => {
                         const cDrawing = await getDrawing(drawingId);
@@ -379,10 +538,14 @@ export default class CAD {
                             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,
+                            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]);
+                                xOffsetParam,
+                                yOffsetParam,
+                                zOffsetParam,
+                            ]);
                         });
                         await ccAPI.assemblyBuilder.updateFastenedConstraints(drawingId, constrToAdd);
                     });
@@ -415,9 +578,13 @@ export default class CAD {
                             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,
+                            constrToAdd.push([
+                                constr.constrId,
                                 [constr.mate1.matePath, constr.mate1.wcsId, constr.mate1.flip, constr.mate1.reoriented],
-                                xOffsetParam, yOffsetParam, zOffsetParam]);
+                                xOffsetParam,
+                                yOffsetParam,
+                                zOffsetParam,
+                            ]);
                         });
                         await ccAPI.assemblyBuilder.updateFastenedOriginConstraints(drawingId, constrToAdd);
                     });
@@ -632,6 +799,37 @@ export default class CAD {
                         return null;
                     }, refId);
                 },
+                setCurrentNode: (refId) => {
+                    return this.resolve(async ([rRefId]) => {
+                        await ccAPI.assemblyBuilder.setCurrentNode(drawingId, rRefId);
+                    }, refId);
+                },
+                getCurrentNode: () => {
+                    return this.resolve(async () => {
+                        const drw = getDrawing(drawingId);
+                        return drw.structure.currentNode;
+                    });
+                },
+                getCoordSysFromNode: (refId) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const coordSys = ccUtils.assembly.getCoordSysFromNode(drawingId, rRefId);
+                        if (coordSys != undefined) {
+                            return coordSys;
+                        }
+                        return null;
+                    }, refId);
+                },
+                setCurrentProduct: (productId) => {
+                    return this.resolve(async ([rProductId]) => {
+                        await ccAPI.baseModeler.setCurrentProduct(drawingId, rProductId);
+                    }, productId);
+                },
+                getCurrentProduct: () => {
+                    return this.resolve(async () => {
+                        const drw = getDrawing(drawingId);
+                        return drw.structure.currentProduct;
+                    });
+                },
                 getPartFromContainer: (partName) => {
                     return this.resolve(async ([]) => {
                         const partIds = ccUtils.assembly.getPartFromContainer(drawingId, partName);
@@ -695,6 +893,11 @@ export default class CAD {
                         return null;
                     }, partId);
                 },
+                transformNode: (referenceId, ownerId, transformation) => {
+                    return this.resolve(async ([rRefId, rOwnerId]) => {
+                        await ccAPI.assemblyBuilder.setNodeTransformation(drawingId, rRefId, rOwnerId, transformation);
+                    }, referenceId, ownerId);
+                },
                 translate: (partId, featureIds, references, inverted, distance) => {
                     return this.resolve(async ([rPartId, rFeatureIds, rReferences]) => {
                         const translationId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCTranslation, 'Translate');
@@ -763,6 +966,21 @@ export default class CAD {
                         return success;
                     }, partId);
                 },
+                setExpressionSets: (...exprSets) => {
+                    return this.resolve(async ([]) => {
+                        const exprSetsToSet = [];
+                        exprSets.forEach(exprSet => {
+                            const membersToModify = [];
+                            exprSet.members.forEach(mem => {
+                                const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
+                                membersToModify.push([mem.name, [mem.value, isExpr]]);
+                            });
+                            exprSetsToSet.push([exprSet.partId, [], membersToModify, []]);
+                        });
+                        const success = await featureAPI.updateExpressionSets(drawingId, exprSetsToSet);
+                        return success;
+                    });
+                },
                 deleteExpressions: (partId, members) => {
                     return this.resolve(async (resolvedArgs) => {
                         const success = featureAPI.updateExpressionSet(drawingId, resolvedArgs[0], [], [], members);

package/build/index.d.ts

@@ -7,10 +7,12 @@ export { solid, history, createPolyline };
  *
  * Please have a look at https://github.com/awv-informatik/buerli/pull/129 for more information.
  */
-import { ApiHistory as ApiHistory1, ConstraintType as ConstraintType1, Transform as Transform1 } from './history';
+import { ApiHistory as ApiHistory1, ConstraintType as ConstraintType1, Transform as Transform1, DimensionType as DimensionType1, OrientationTypes as OrientationTypes1 } from './history';
 export declare type ApiHistory = ApiHistory1;
 export declare type ConstraintType = ConstraintType1;
 export declare type Transform = Transform1;
+export declare type DimensionType = DimensionType1;
+export declare type OrientationTypes = OrientationTypes1;
 import { ApiNoHistory as ApiNoHistory1, FilletPoint as FilletPoint1, Polyline as Polyline1 } from './solid';
 export declare type ApiNoHistory = ApiNoHistory1;
 export declare type Polyline = Polyline1;

package/build/solid.d.ts

@@ -1,4 +1,3 @@
-import { AwvNodeClient } from '@buerli.io/classcad';
 import { ObjectID } from '@buerli.io/core';
 import { BufferGeometry, Scene, Vector3 } from 'three';
 /**
@@ -434,9 +433,8 @@ export declare type ApiNoHistory = {
 export declare function createPolyline(fPts: FilletPoint[]): Polyline;
 export default class CAD {
     private drawingId;
-    private target;
     queue: Promise<number>;
-    constructor(target: string | AwvNodeClient);
+    constructor();
     init(callback: (api: ApiNoHistory) => void): () => Promise<void>;
     destroy(): void;
 }

package/build/solid.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 import { ccAPI } from '@buerli.io/classcad';
-import { api, getDrawing, init } from '@buerli.io/core';
+import { api, getDrawing } from '@buerli.io/core';
 import { Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
 import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUtils';
 let BufferGeometryUtils = BufferGeometryUtils_;
@@ -68,10 +68,7 @@ const getTouchPoints = (info, radius) => {
     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 dir = endPos.clone().sub(startPos).normalize();
         const maxDist = endPos.distanceTo(controlPos);
         dirs.push(dir);
         maxDists.push(maxDist);
@@ -194,17 +191,14 @@ const makeCCData = (curves) => {
     });
 };
 export default class CAD {
-    constructor(target) {
+    constructor() {
         this.drawingId = null;
         this.queue = Promise.resolve(0);
         this.queue = Promise.resolve(0);
-        if (typeof target !== 'string')
-            this.target = target;
-        init({ url: typeof target === 'string' ? target : '' });
     }
     init(callback) {
         const promise = new Promise(async (resolve, reject) => {
-            const drawingId = await ccAPI.base.createCCDrawing('solid', this.target);
+            const drawingId = await ccAPI.base.createCCDrawing('solid');
             if (!drawingId)
                 throw new Error('Drawing could not be created');
             this.drawingId = drawingId;

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.0.36-beta.0",
+  "version": "0.1.0",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
+  "license": "ISC",
   "repository": {},
   "main": "build/index.js",
   "module": "build/index.js",
@@ -10,47 +11,24 @@
   "sideEffects": false,
   "scripts": {
     "ver": "npm version",
-    "prepack": "npm run build:dist",
+    "prepack": "npm run clean && npm run build",
     "clean": "rimraf ./build",
-    "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\"",
+    "build": "tsc",
+    "build:dev": "tsc --sourceMap true --declarationMap true",
     "test": "echo no tests yet",
     "lint": "eslint \"./src/**/*.ts?(x)\"",
-    "prettier": "prettier --write \"./{src,tests}/**/*.{js,jsx,ts,tsx,json}\""
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
-  },
-  "prettier": {
-    "semi": false,
-    "arrowParens": "avoid",
-    "trailingComma": "all",
-    "singleQuote": true,
-    "jsxBracketSameLine": true,
-    "tabWidth": 2,
-    "printWidth": 120
+    "prettify": "prettier --write \"./{src,tests}/**/*.{js,jsx,ts,tsx,json}\""
   },
-  "lint-staged": {
-    "*.{js,jsx,ts,tsx,json,md}": [
-      "prettier --write",
-      "git add"
-    ]
-  },
-  "license": "ISC",
   "devDependencies": {
-    "@types/three": "^0.130.1",
+    "@types/three": "^0.137",
     "copyfiles": "^2.1.1",
     "rimraf": "^2.6.3",
-    "three": "^0.131.3",
-    "typescript": "4.1.2"
+    "three": "^0.138"
   },
   "peerDependencies": {
-    "three": ">=0.128"
+    "three": ">=0.138"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.0.36-beta.0"
+    "@buerli.io/classcad": "0.1.0"
   }
 }