@buerli.io/headless 0.8.0 → 0.9.0-beta.1

package/build/esm/history.js

@@ -7,7 +7,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 /* eslint-disable max-lines */
 import { ccAPI, CCClasses, ccUtils, DataType, SVGModusType, } from '@buerli.io/classcad';
-import { api, getDrawing, MathUtils, BuerliScope, createInfo, } from '@buerli.io/core';
+import { api, getDrawing, MathUtils, BuerliScope, createInfo, Measure, } from '@buerli.io/core';
 import { Group, Matrix4, Mesh, MeshStandardMaterial, Scene } from 'three';
 import { mergeBufferGeometries } from 'three-stdlib';
 import { waitForSelect } from './utils/selection';
@@ -21,12 +21,6 @@ const geometryAPI = ccAPI.geometry;
 const baseUtils = ccUtils.base;
 const asmUtils = ccUtils.assembly;
 const partUtils = ccUtils.part;
-const resolveVec = (value) => {
-    if (Array.isArray(value))
-        return { x: value[0], y: value[1], z: value[2] };
-    else
-        return value;
-};
 /**
  * Returns the cclass of the given dimension type
  * @param type type of the dimension as string
@@ -112,8 +106,8 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
             const matrix = object.coordinateSystem ? MathUtils.convertToMatrix4(object.coordinateSystem) : new Matrix4();
             matrix.decompose(part.position, part.quaternion, part.scale);
             part.updateMatrix();
-            part.userData = { id: object.id }; // product reference id
-            part.name = object.name; // product reference name
+            part.userData = { id: object.id }; // instance id
+            part.name = object.name; // instance name
             for (const entity of entities) {
                 let cachedEntity = cDrawing.geometry.cache[entity];
                 if (!cachedEntity) {
@@ -209,8 +203,8 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
         const matrix = object.coordinateSystem ? MathUtils.convertToMatrix4(object.coordinateSystem) : new Matrix4();
         matrix.decompose(assembly.position, assembly.quaternion, assembly.scale);
         assembly.updateMatrix();
-        assembly.userData = { id: object.id }; // assembly root or product reference id
-        assembly.name = object.name; // assembly root or product reference name
+        assembly.userData = { id: object.id }; // assembly root or instance id
+        assembly.name = object.name; // assembly root or instance name
         result.nodes[assembly.name] = assembly;
         root.add(assembly);
         for (const child of object.children) {
@@ -220,6 +214,12 @@ const createRecursiveScene = async (object, drawingId, root, result, options) =>
         }
     }
 };
+const resolveVec = (value) => {
+    if (Array.isArray(value))
+        return { x: value[0], y: value[1], z: value[2] };
+    else
+        return value;
+};
 export default class CAD {
     constructor() {
         this.drawingId = null;
@@ -240,31 +240,31 @@ export default class CAD {
                 throw new Error('Drawing could not be created');
             this.drawingId = drawingId;
             const publicApi = {
-                addNodes: async (...nodes) => {
+                addInstances: async (...instances) => {
                     var e_1, _a;
-                    const nodesToAdd = [];
+                    const instancesToAdd = [];
                     try {
-                        for (var nodes_1 = __asyncValues(nodes), nodes_1_1; nodes_1_1 = await nodes_1.next(), !nodes_1_1.done;) {
-                            const node = nodes_1_1.value;
-                            const [rProductId, rOwnerId] = await new Promise(res => this.resolve(id => res(id), node.productId, node.ownerId));
-                            const nodeParam = {
-                                referenceId: rProductId,
+                        for (var instances_1 = __asyncValues(instances), instances_1_1; instances_1_1 = await instances_1.next(), !instances_1_1.done;) {
+                            const instance = instances_1_1.value;
+                            const [rProductId, rOwnerId] = await new Promise(res => this.resolve(id => res(id), instance.productId, instance.ownerId));
+                            const instanceParam = {
+                                productId: rProductId,
                                 ownerId: rOwnerId,
-                                transformation: node.transformation,
-                                name: node.name,
-                                options: Object.assign(Object.assign({}, node.options), { isLocal: true }), // in non-interactive mode, the transformation is local to the owner
+                                transformation: instance.transformation,
+                                name: instance.name,
+                                options: Object.assign(Object.assign({}, instance.options), { isLocal: true }), // in non-interactive mode, the transformation is local to the owner
                             };
-                            nodesToAdd.push(nodeParam);
+                            instancesToAdd.push(instanceParam);
                         }
                     }
                     catch (e_1_1) { e_1 = { error: e_1_1 }; }
                     finally {
                         try {
-                            if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) await _a.call(nodes_1);
+                            if (instances_1_1 && !instances_1_1.done && (_a = instances_1.return)) await _a.call(instances_1);
                         }
                         finally { if (e_1) throw e_1.error; }
                     }
-                    return assemblyBuilderAPI.addNodes(drawingId, nodesToAdd);
+                    return assemblyBuilderAPI.addInstances(drawingId, instancesToAdd);
                 },
                 addDimensions: async (...dimensions) => {
                     var e_2, _a;
@@ -344,17 +344,17 @@ export default class CAD {
                         return drawing2DAPI.removeDimensions(drawingId, rDimensionIds);
                     }, ...dimensionIds);
                 },
-                linearPattern: (partId, entities, references1, params1, references2, params2) => {
-                    return this.resolve(async ([rPartId, rEntities, rReferences1, rReferences2]) => {
+                linearPattern: (partId, operations, references1, params1, references2, params2) => {
+                    return this.resolve(async ([rPartId, rOperations, rReferences1, rReferences2]) => {
                         const patternId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCLinearPattern, 'LinearPattern');
                         if (patternId != null) {
                             // entities
                             const cDrawing = await getDrawing(drawingId);
                             const entArray = [];
-                            for (const rEntity of rEntities) {
-                                const entity = cDrawing.structure.tree[(await rEntity)].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
                                 }
                             }
                             const distance1Param = {
@@ -402,19 +402,19 @@ export default class CAD {
                             return patternId;
                         }
                         return null;
-                    }, partId, entities, references1, references2);
+                    }, partId, operations, references1, references2);
                 },
-                circularPattern: (partId, entities, references, params) => {
-                    return this.resolve(async ([rPartId, rEntities, ...rReferences]) => {
+                circularPattern: (partId, operations, references, params) => {
+                    return this.resolve(async ([rPartId, rOperations, ...rReferences]) => {
                         const patternId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCCircularPattern, 'CircularPattern');
                         if (patternId != null) {
                             // entities
                             const cDrawing = await getDrawing(drawingId);
                             const entArray = [];
-                            for (const rEntity of rEntities) {
-                                const entity = cDrawing.structure.tree[(await rEntity)].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
                                 }
                             }
                             const angleParam = { value: params.angle, isExpr: typeof params.angle === 'string' };
@@ -430,11 +430,11 @@ export default class CAD {
                             return patternId;
                         }
                         return null;
-                    }, partId, entities, ...references);
+                    }, partId, operations, ...references);
                 },
                 extrusion: (partId, sketchOrRegionIds, type, limit1, limit2, taperAngle, direction, capEnds) => {
                     return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
-                        const extrusion = await featureAPI.createExtrusion(drawingId, rPartId);
+                        const extrusion = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCExtrusion, 'Extrusion');
                         if (extrusion) {
                             const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
                             if (sketchLines) {
@@ -456,7 +456,7 @@ export default class CAD {
                 },
                 revolve: (partId, sketchOrRegionIds, axisIds, angle1, angle2, inverted) => {
                     return this.resolve(async ([rPartId, rSketchOrRegionIds, ...rAxisIds]) => {
-                        const revolve = await featureAPI.createRevolve(drawingId, rPartId);
+                        const revolve = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCRevolve, 'Revolve');
                         if (revolve) {
                             const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
                             if (sketchLines) {
@@ -468,26 +468,23 @@ export default class CAD {
                         }
                     }, partId, sketchOrRegionIds, ...axisIds);
                 },
-                boolean: (partId, type, entities) => {
-                    return this.resolve(async ([rPartId, rEntities]) => {
+                boolean: (partId, type, operations) => {
+                    return this.resolve(async ([rPartId, rOperations]) => {
                         const cDrawing = await getDrawing(drawingId);
                         const entArray = [];
-                        for (const rEntity of rEntities) {
-                            const entity = cDrawing.structure.tree[(await rEntity)].children;
-                            if (entity != undefined) {
-                                entArray.push(entity[0]);
+                        for (const rOperation of rOperations) {
+                            const entities = cDrawing.structure.tree[(await rOperation)].children;
+                            if (entities != undefined) {
+                                entArray.push(entities[0]);
                             }
                         }
-                        const boolId = await featureAPI.createBooleanOperation(drawingId, rPartId, {
-                            type,
-                            entities: entArray,
-                        });
+                        const boolId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCUnion, 'Union');
                         if (boolId != null) {
                             await featureAPI.updateBooleanOperation(drawingId, boolId, type, entArray);
                             return boolId;
                         }
                         return null;
-                    }, partId, entities);
+                    }, partId, operations);
                 },
                 box: (partId, references, width, length, height) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
@@ -540,11 +537,11 @@ export default class CAD {
                         return null;
                     }, partId, ...references);
                 },
-                createFastenedConstraint: async (asmId, mate1, mate2, xOffset, yOffset, zOffset, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createFastenedConstraint: async (id, mate1, mate2, xOffset, yOffset, zOffset, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCFastenedConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCFastenedConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -604,10 +601,10 @@ export default class CAD {
                     }
                     await assemblyBuilderAPI.updateFastenedConstraints(drawingId, constrToAdd);
                 },
-                createFastenedOriginConstraint: async (asmId, mate1, xOffset, yOffset, zOffset, name) => {
-                    const [rAsmId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId));
+                createFastenedOriginConstraint: async (id, mate1, xOffset, yOffset, zOffset, name) => {
+                    const [rId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId));
                     const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCFastenedOriginConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCFastenedOriginConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -659,11 +656,11 @@ export default class CAD {
                     }
                     await assemblyBuilderAPI.updateFastenedOriginConstraints(drawingId, constraintsToAdd);
                 },
-                createCylindricalConstraint: async (asmId, mate1, mate2, zOffsetLimits, zRotationLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createCylindricalConstraint: async (id, mate1, mate2, zOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCCylindricalConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCCylindricalConstraint, name);
                     if (constraintId != null) {
                         await assemblyBuilderAPI.updateCylindricalConstraints(drawingId, [
                             {
@@ -725,11 +722,11 @@ export default class CAD {
                     }
                     await assemblyBuilderAPI.updateCylindricalConstraints(drawingId, constrToAdd);
                 },
-                createRevoluteConstraint: async (asmId, mate1, mate2, zOffset, zRotationLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createRevoluteConstraint: async (id, mate1, mate2, zOffset, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCRevoluteConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCRevoluteConstraint, name);
                     if (constraintId != null) {
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
                         await assemblyBuilderAPI.updateRevoluteConstraints(drawingId, [
@@ -793,11 +790,11 @@ export default class CAD {
                     }
                     await assemblyBuilderAPI.updateRevoluteConstraints(drawingId, constrToAdd);
                 },
-                createSliderConstraint: async (asmId, mate1, mate2, xOffset, yOffset, zOffsetLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createSliderConstraint: async (id, mate1, mate2, xOffset, yOffset, zOffsetLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCSliderConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCSliderConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
@@ -865,11 +862,11 @@ export default class CAD {
                     }
                     await assemblyBuilderAPI.updateSliderConstraints(drawingId, constrToAdd);
                 },
-                createPlanarConstraint: async (asmId, mate1, mate2, zOffset, xOffsetLimits, yOffsetLimits, zRotationLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createPlanarConstraint: async (id, mate1, mate2, zOffset, xOffsetLimits, yOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCPlanarConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCPlanarConstraint, name);
                     if (constraintId != null) {
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
                         await assemblyBuilderAPI.updatePlanarConstraints(drawingId, [
@@ -937,11 +934,11 @@ export default class CAD {
                     }
                     await assemblyBuilderAPI.updatePlanarConstraints(drawingId, constrToAdd);
                 },
-                createParallelConstraint: async (asmId, mate1, mate2, xOffsetLimits, yOffsetLimits, zOffsetLimits, zRotationLimits, name) => {
-                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                createParallelConstraint: async (id, mate1, mate2, xOffsetLimits, yOffsetLimits, zOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCParallelConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rId, CCClasses.CCParallelConstraint, name);
                     if (constraintId != null) {
                         await assemblyBuilderAPI.updateParallelConstraints(drawingId, [
                             {
@@ -1194,26 +1191,31 @@ export default class CAD {
                     }, partId, references);
                 },
                 selectGeometry: (types, count) => {
+                    const drId = this.drawingId;
                     return this.resolve(async ([]) => {
                         const filter = (scope, data) => scope === BuerliScope && types.some(type => type === data);
                         // Check count param. If not set use by default 1, else check if not < 1
                         const lCount = count ? (count < 1 ? 1 : count) : 1;
-                        const selections = await waitForSelect(lCount, filter, (resolveSelection, items, diff) => {
+                        const selections = (await waitForSelect(lCount, filter, (resolveSelection, items, diff) => {
                             if (items.length > lCount - 1) {
                                 resolveSelection(items);
                             }
-                        });
+                        }));
                         const interactionInfos = [];
                         for (const selection of selections) {
                             // Get matching points from selected geometry and add to userData. TODO: Only if in part mode useful?
                             const points = await geometryAPI.getPointsByGeometries(drawingId, [selection.data.graphicId]);
+                            const matrix = getDrawing(drId).api.structure.calculateGlobalTransformation(selection.data.productId);
+                            const clone = selection.data.geometry.clone().applyMatrix4(matrix);
+                            // TODO: Should the transform code be moved to something else than Measure? It's helpful for more cases than just measuring.
+                            const transformedData = Measure.transform([selection.data], drId)[0];
                             const interactionInfo = createInfo({
                                 objectId: selection.data.container.ownerId,
                                 prodRefId: selection.data.productId,
                                 containerId: selection.data.container.id,
                                 graphicId: selection.data.graphicId,
                                 // objectPath: ?,  TODO: Add path to the root in expanded tree, as soon as available
-                                userData: Object.assign(Object.assign({}, selection.data), { matchingPoints: points }),
+                                userData: Object.assign(Object.assign({}, transformedData), { geometry: clone, matchingPoints: points }),
                             });
                             interactionInfos.push(interactionInfo);
                         }
@@ -1226,55 +1228,55 @@ export default class CAD {
                         return geoms;
                     }, partId);
                 },
-                getAssemblyFromContainer: (asmName) => {
+                getAssemblyTemplate: (asmName) => {
                     return this.resolve(async ([]) => {
-                        const asmIds = asmUtils.getAssemblyFromContainer(drawingId, asmName);
+                        const asmIds = asmUtils.getAssemblyTemplate(drawingId, asmName);
                         if (asmIds != undefined) {
                             return Array.isArray(asmIds) ? asmIds : [asmIds];
                         }
                         return null;
                     });
                 },
-                getAssemblyNode: (refId, nodeName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const nodeIds = asmUtils.getAssemblyNode(drawingId, rRefId, nodeName);
-                        if (nodeIds != undefined) {
-                            return Array.isArray(nodeIds) ? nodeIds : [nodeIds];
+                getInstance: (id, instanceName) => {
+                    return this.resolve(async ([rId]) => {
+                        const instances = asmUtils.getInstance(drawingId, rId, instanceName);
+                        if (instances != undefined) {
+                            return Array.isArray(instances) ? instances : [instances];
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getProductOfNode: (refIds) => {
-                    return this.resolve(async ([rRefIds]) => {
+                getProductsOfInstances: (instanceIds) => {
+                    return this.resolve(async ([rInstanceIds]) => {
                         const drawing = getDrawing(drawingId);
                         const tree = drawing.structure.tree;
                         const products = [];
-                        for (const rRefId of rRefIds) {
-                            const product = asmUtils.findProduct(rRefId, tree);
+                        for (const rInstanceId of rInstanceIds) {
+                            const product = asmUtils.findProduct(rInstanceId, tree);
                             products.push(product);
                         }
                         return products;
-                    }, refIds);
+                    }, instanceIds);
                 },
-                setCurrentNode: (refId) => {
-                    return this.resolve(async ([rRefId]) => {
-                        await assemblyBuilderAPI.setCurrentNode(drawingId, rRefId);
-                    }, refId);
+                setCurrentInstance: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        await assemblyBuilderAPI.setCurrentInstance(drawingId, rId);
+                    }, id);
                 },
-                getCurrentNode: () => {
+                getCurrentInstance: () => {
                     return this.resolve(async () => {
                         const drw = getDrawing(drawingId);
-                        return drw.structure.currentNode;
+                        return drw.structure.currentInstance;
                     });
                 },
-                getCoordSysFromNode: (refId) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const coordSys = asmUtils.getCoordSysFromNode(drawingId, rRefId);
+                getTransformation: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        const coordSys = asmUtils.getTransformation(drawingId, rId);
                         if (coordSys != undefined) {
                             return coordSys;
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
                 setCurrentProduct: (productId) => {
                     return this.resolve(async ([rProductId]) => {
@@ -1287,33 +1289,33 @@ export default class CAD {
                         return drw.structure.currentProduct;
                     });
                 },
-                getPartFromContainer: (partName) => {
+                getPartTemplate: (partName) => {
                     return this.resolve(async ([]) => {
-                        const partIds = asmUtils.getPartFromContainer(drawingId, partName);
+                        const partIds = asmUtils.getPartTemplate(drawingId, partName);
                         if (partIds != undefined) {
                             return Array.isArray(partIds) ? partIds : [partIds];
                         }
                         return null;
                     });
                 },
-                getWorkCoordSystem: (refId, wcsName) => {
-                    return this.resolve(async ([rRefId]) => {
+                getWorkCoordSystem: (id, wcsName) => {
+                    return this.resolve(async ([rId]) => {
                         console.warn('Warning: getWorkCoordSystem() is deprecated, use getWorkGeometry() instead, getWorkCoordSystem() will be removed in a future release.');
-                        const wcsIds = asmUtils.getWorkCoordSystem(drawingId, rRefId, wcsName);
+                        const wcsIds = asmUtils.getWorkCoordSystem(drawingId, rId, wcsName);
                         if (wcsIds != undefined) {
                             return Array.isArray(wcsIds) ? wcsIds : [wcsIds];
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getSketchRegion: (refId, sketchRegionName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const sRIds = partUtils.getSketchRegion(drawingId, rRefId, sketchRegionName);
+                getSketchRegion: (id, sketchRegionName) => {
+                    return this.resolve(async ([rId]) => {
+                        const sRIds = partUtils.getSketchRegion(drawingId, rId, sketchRegionName);
                         if (sRIds != undefined) {
                             return Array.isArray(sRIds) ? sRIds : [sRIds];
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
                 getWorkGeometry: (refId, type, wgName) => {
                     return this.resolve(async ([rRefId]) => {
@@ -1334,9 +1336,9 @@ export default class CAD {
                         return null;
                     }, refId);
                 },
-                getFastenedConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getFastenedConstraint(drawingId, rRefId, constrName);
+                getFastenedConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getFastenedConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1348,11 +1350,11 @@ export default class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getFastenedOriginConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getFastenedOriginConstraint(drawingId, rRefId, constrName);
+                getFastenedOriginConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getFastenedOriginConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1363,11 +1365,11 @@ export default class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getRevoluteConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getRevoluteConstraint(drawingId, rRefId, constrName);
+                getRevoluteConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getRevoluteConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1378,11 +1380,11 @@ export default class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getSliderConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getSliderConstraint(drawingId, rRefId, constrName);
+                getSliderConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getSliderConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1394,11 +1396,11 @@ export default class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getPlanarConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getPlanarConstraint(drawingId, rRefId, constrName);
+                getPlanarConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getPlanarConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1411,11 +1413,11 @@ export default class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getParallelConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getParallelConstraint(drawingId, rRefId, constrName);
+                getParallelConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getParallelConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1428,11 +1430,11 @@ export default class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
-                getCylindricalConstraint: (refId, constrName) => {
-                    return this.resolve(async ([rRefId]) => {
-                        const constraint = asmUtils.getCylindricalConstraint(drawingId, rRefId, constrName);
+                getCylindricalConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getCylindricalConstraint(drawingId, rId, constrName);
                         if (constraint != undefined) {
                             return {
                                 constrId: constraint.constrId,
@@ -1443,7 +1445,7 @@ export default class CAD {
                             };
                         }
                         return null;
-                    }, refId);
+                    }, id);
                 },
                 getFeatureByName: (partId, featureName) => {
                     return this.resolve(async ([rProductId]) => {
@@ -1454,19 +1456,19 @@ export default class CAD {
                         return null;
                     }, partId);
                 },
-                getGeometryInformation: (objectId) => {
-                    return this.resolve(async ([rProductOrSolidId]) => {
-                        const values = await baseModelerAPI.getGeometryInformation(drawingId, rProductOrSolidId);
+                getGeometryInformation: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        const values = await baseModelerAPI.getGeometryInformation(drawingId, rId);
                         if (values !== null) {
                             return { centerOfGravity: values[0], volume: values[1] };
                         }
                         return null;
-                    }, objectId);
+                    }, id);
                 },
-                removeNodes: (...nodes) => {
-                    return this.resolve(async ([...rNodes]) => {
-                        return assemblyBuilderAPI.removeNodes(drawingId, rNodes);
-                    }, ...nodes);
+                removeInstances: (...instances) => {
+                    return this.resolve(async ([...rInstances]) => {
+                        return assemblyBuilderAPI.removeInstances(drawingId, rInstances);
+                    }, ...instances);
                 },
                 importFeature: (partId, content, format, name) => {
                     return this.resolve(async ([rPartId]) => {
@@ -1522,40 +1524,40 @@ export default class CAD {
                         await sketcherAPI.setSketchRefs(drawingId, rSketchId, rPlaneId, invertPlane, rAxisId, isXAxis, invertAxis, rOriginId);
                     }, sketchId, planeId, axisId, originId);
                 },
-                transformNodes: async (...nodes) => {
+                transformInstances: async (...instances) => {
                     var e_11, _a;
-                    const nodesToTransform = [];
+                    const instancesToTransform = [];
                     try {
-                        for (var nodes_2 = __asyncValues(nodes), nodes_2_1; nodes_2_1 = await nodes_2.next(), !nodes_2_1.done;) {
-                            const node = nodes_2_1.value;
-                            const [rReferenceId] = await new Promise(res => this.resolve(id => res(id), node.referenceId));
-                            const nodeParam = {
-                                referenceId: rReferenceId,
-                                transformation: node.transformation,
+                        for (var instances_2 = __asyncValues(instances), instances_2_1; instances_2_1 = await instances_2.next(), !instances_2_1.done;) {
+                            const instance = instances_2_1.value;
+                            const [rInstanceId] = await new Promise(res => this.resolve(id => res(id), instance.id));
+                            const instanceParam = {
+                                id: rInstanceId,
+                                transformation: instance.transformation,
                                 options: { isLocal: true }, // in non-interactive mode, the transformation is local to the owner
                             };
-                            nodesToTransform.push(nodeParam);
+                            instancesToTransform.push(instanceParam);
                         }
                     }
                     catch (e_11_1) { e_11 = { error: e_11_1 }; }
                     finally {
                         try {
-                            if (nodes_2_1 && !nodes_2_1.done && (_a = nodes_2.return)) await _a.call(nodes_2);
+                            if (instances_2_1 && !instances_2_1.done && (_a = instances_2.return)) await _a.call(instances_2);
                         }
                         finally { if (e_11) throw e_11.error; }
                     }
-                    return assemblyBuilderAPI.transformNodes(drawingId, nodesToTransform);
+                    return assemblyBuilderAPI.transformInstances(drawingId, instancesToTransform);
                 },
-                translate: (partId, featureIds, references, inverted, distance) => {
-                    return this.resolve(async ([rPartId, rFeatureIds, ...rReferences]) => {
+                translate: (partId, operations, references, inverted, distance) => {
+                    return this.resolve(async ([rPartId, rOperations, ...rReferences]) => {
                         const translationId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCTranslation, 'Translate');
                         if (translationId !== null) {
                             const cDrawing = await getDrawing(drawingId);
                             const entArray = [];
-                            for (const rFeatureId of rFeatureIds) {
-                                const entity = cDrawing.structure.tree[(await rFeatureId)].children;
-                                if (entity != undefined) {
-                                    entArray.push(entity[0]);
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
                                 }
                             }
                             const dist = { value: distance, isExpr: typeof distance === 'string' };
@@ -1563,7 +1565,7 @@ export default class CAD {
                             return translationId;
                         }
                         return null;
-                    }, partId, featureIds, ...references);
+                    }, partId, operations, ...references);
                 },
                 // TODO: Remove this method. Is it necessary?
                 updateTranslate: (translationId, distance) => {
@@ -1588,11 +1590,11 @@ export default class CAD {
                 saveToUrl: (url, filetype) => {
                     return baseModelerAPI.saveToUrl(drawingId, url, filetype);
                 },
-                load: (content, type) => {
-                    return baseModelerAPI.load(drawingId, content, type);
+                load: (content, type, options) => {
+                    return baseModelerAPI.load(drawingId, content, type, '', options);
                 },
-                loadFromUrl: (url, filetype) => {
-                    return baseModelerAPI.loadFromUrl(drawingId, url, filetype, true);
+                loadFromUrl: (url, filetype, options) => {
+                    return baseModelerAPI.loadFromUrl(drawingId, url, filetype, true, options);
                 },
                 loadProduct: (content, type, options) => {
                     return assemblyBuilderAPI.loadProduct(drawingId, content, type, '', options);
@@ -1653,16 +1655,16 @@ export default class CAD {
                         return null;
                     }, partId, ...references);
                 },
-                mirror: async (partId, entities, references) => {
+                mirror: async (partId, operations, references) => {
                     const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
-                    const rEntities = await new Promise(res => this.resolve(ids => res(ids), ...entities));
+                    const rOperations = await new Promise(res => this.resolve(ids => res(ids), ...operations));
                     const rReferences = await new Promise(res => this.resolve(paths => res(paths), ...references));
                     const cDrawing = getDrawing(drawingId);
                     const entArray = [];
-                    for (const rEntity of rEntities) {
-                        const entity = cDrawing.structure.tree[rEntity].children;
-                        if (entity != undefined) {
-                            entArray.push(entity[0]);
+                    for (const rOperation of rOperations) {
+                        const entities = cDrawing.structure.tree[rOperation].children;
+                        if (entities != undefined) {
+                            entArray.push(entities[0]);
                         }
                     }
                     const mirrorId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCMirror, 'Mirror');