@buerli.io/headless 0.4.1 → 0.5.0-beta.2

package/build/{history.js → esm/history.js}

@@ -39,12 +39,13 @@ const getDataType = (value) => {
  * @returns cclass type of given type
  */
 const getDimensionType = (type) => {
+    let cclass = CCClasses.CCLinearDimension;
     switch (type) {
         case 'LinearDimension':
-            return CCClasses.CCLinearDimension;
-        case undefined:
+            cclass = CCClasses.CCLinearDimension;
             break;
     }
+    return cclass;
 };
 /**
  * Transforms the transformation which is local to the ownerId into global
@@ -283,74 +284,94 @@ export default class CAD {
                         return ccAPI.assemblyBuilder.addNode(drawingId, rProductId, rOwnerId, globalTransformation, name);
                     }, productId, ownerId);
                 },
-                addNodes: (...nodes) => {
-                    return this.resolve(async ([...rNodes]) => {
-                        const nodesToAdd = [];
-                        rNodes.forEach(node => {
-                            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);
-                    }, ...nodes);
+                addNodes: async (...nodes) => {
+                    var e_1, _a;
+                    const nodesToAdd = [];
+                    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,
+                                ownerId: rOwnerId,
+                                transformation: getGlobalTransformation(drawingId, rOwnerId, node.transformation) || node.transformation,
+                                name: node.name,
+                            };
+                            nodesToAdd.push(nodeParam);
+                        }
+                    }
+                    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);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    return ccAPI.assemblyBuilder.addNodes(drawingId, nodesToAdd);
                 },
                 addDimension: (dim) => {
                     return this.resolve(async ([rProductId]) => {
                         const dimensionType = getDimensionType(dim.dimParam.dimType);
-                        if (dim.dimParam.dimOrientation !== undefined && dim.dxfView !== 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,
-                                    dim.dimParam.dimOrientation,
-                                    dim.dimParam.dimColor || 256,
-                                    dim.dimParam.dimLayer || '1',
-                                ],
-                                dim.dxfView,
-                            ];
-                            return ccAPI.drawing2D.addDimension(drawingId, dimParam);
-                        }
+                        const dimParam = {
+                            productId: rProductId,
+                            param: {
+                                type: dimensionType,
+                                name: dim.dimParam.dimName,
+                                label: dim.dimParam.dimLabel,
+                                value: dim.dimParam.dimValue,
+                                startPos: dim.dimParam.dimStartPos,
+                                endPos: dim.dimParam.dimEndPos,
+                                textPos: dim.dimParam.dimTextPos,
+                                textAngle: dim.dimParam.dimTextAngle,
+                                orientation: dim.dimParam.dimOrientation,
+                                color: dim.dimParam.dimColor,
+                                layer: dim.dimParam.dimLayer,
+                            },
+                            dxfView: dim.dxfView,
+                        };
+                        return ccAPI.drawing2D.addDimension(drawingId, dimParam);
                     }, dim.productId);
                 },
-                addDimensions: (...dimensions) => {
-                    return this.resolve(async ([...rDimensions]) => {
-                        const dimsToAdd = [];
-                        rDimensions.forEach(dim => {
+                addDimensions: async (...dimensions) => {
+                    var e_2, _a;
+                    const dimParamsToAdd = [];
+                    try {
+                        for (var dimensions_1 = __asyncValues(dimensions), dimensions_1_1; dimensions_1_1 = await dimensions_1.next(), !dimensions_1_1.done;) {
+                            const dim = dimensions_1_1.value;
+                            const [rProductId] = await new Promise(res => this.resolve(id => res(id), dim.productId));
                             const dimensionType = getDimensionType(dim.dimParam.dimType);
-                            if (dim.dimParam.dimOrientation !== undefined && dim.dxfView !== 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,
-                                        dim.dimParam.dimOrientation,
-                                        dim.dimParam.dimColor || 256,
-                                        dim.dimParam.dimLayer || '1',
-                                    ],
-                                    dim.dxfView,
-                                ]);
-                            }
-                        });
-                        return ccAPI.drawing2D.addDimensions(drawingId, dimsToAdd);
-                    }, ...dimensions);
+                            const dimParam = {
+                                productId: rProductId,
+                                param: {
+                                    type: dimensionType,
+                                    name: dim.dimParam.dimName,
+                                    label: dim.dimParam.dimLabel,
+                                    value: dim.dimParam.dimValue,
+                                    startPos: dim.dimParam.dimStartPos,
+                                    endPos: dim.dimParam.dimEndPos,
+                                    textPos: dim.dimParam.dimTextPos,
+                                    textAngle: dim.dimParam.dimTextAngle,
+                                    orientation: dim.dimParam.dimOrientation,
+                                    color: dim.dimParam.dimColor,
+                                    layer: dim.dimParam.dimLayer,
+                                },
+                                dxfView: dim.dxfView,
+                            };
+                            dimParamsToAdd.push(dimParam);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (dimensions_1_1 && !dimensions_1_1.done && (_a = dimensions_1.return)) await _a.call(dimensions_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    return ccAPI.drawing2D.addDimensions(drawingId, dimParamsToAdd);
                 },
                 create2DViews: (productId, viewTypes, viewOptions) => {
                     return this.resolve(async ([rProductId]) => {
-                        const color = (viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.color) ? viewOptions.color : 256;
-                        const layer = (viewOptions === null || viewOptions === void 0 ? void 0 : viewOptions.layer) ? viewOptions.layer : '0';
-                        const viewIds = await ccAPI.drawing2D.create2DViews(drawingId, rProductId, viewTypes, [color, layer]);
+                        const viewIds = await ccAPI.drawing2D.create2DViews(drawingId, rProductId, viewTypes, viewOptions);
                         if (viewIds !== null) {
                             await ccAPI.drawing2D.centerAllViews(drawingId, rProductId, viewTypes);
                             return viewIds;
@@ -366,13 +387,7 @@ export default class CAD {
                 },
                 place2DViews: (productId, viewPositions) => {
                     return this.resolve(async ([rProductId]) => {
-                        const viewPositionParams = [];
-                        viewPositions.forEach(viewPos => {
-                            if (viewPos.viewType !== undefined) {
-                                viewPositionParams.push([viewPos.viewType, viewPos.vector]);
-                            }
-                        });
-                        return ccAPI.drawing2D.place2DViews(drawingId, rProductId, viewPositionParams);
+                        return ccAPI.drawing2D.place2DViews(drawingId, rProductId, viewPositions);
                     }, productId);
                 },
                 exportDXF: (productId, dxfTemplateFilename) => {
@@ -603,7 +618,7 @@ export default class CAD {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                        await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, constraintId, [rMatePath1, rWcs1, mate1.flip, mate1.reoriented], [rMatePath2, rWcs2, mate2.flip, mate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                        await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, constraintId, { matePath: rMatePath1, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, { matePath: rMatePath2, wcsId: rWcs2, flip: mate2.flip, reoriented: mate2.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
                         return constraintId;
                     }
                     return null;
@@ -615,10 +630,10 @@ export default class CAD {
                     const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                     const yOffsetParam = { value: yOffset, isExpr: typeof xOffset === 'string' };
                     const zOffsetParam = { value: zOffset, isExpr: typeof xOffset === 'string' };
-                    await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, rConstrId, [rMatePath1, rWcs1, mate1.flip, mate1.reoriented], [rMatePath2, rWcs2, mate2.flip, mate2.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                    await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, rConstrId, { matePath: rMatePath1, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, { matePath: rMatePath2, wcsId: rWcs2, flip: mate2.flip, reoriented: mate2.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
                 },
                 updateFastenedConstraints: async (...constraints) => {
-                    var e_1, _a;
+                    var e_3, _a;
                     const constrToAdd = [];
                     try {
                         for (var constraints_1 = __asyncValues(constraints), constraints_1_1; constraints_1_1 = await constraints_1.next(), !constraints_1_1.done;) {
@@ -626,25 +641,35 @@ export default class CAD {
                             const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId, constr.mate2.wcsId));
                             const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
                             const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
-                            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([
-                                rConstrId,
-                                [rMatePath1, rWcs1, constr.mate1.flip, constr.mate1.reoriented],
-                                [rMatePath2, rWcs2, constr.mate2.flip, constr.mate2.reoriented],
-                                xOffsetParam,
-                                yOffsetParam,
-                                zOffsetParam,
-                            ]);
+                            const xOffsetParam = { value: constr.xOffset, isExpr: typeof constr.xOffset === 'string' };
+                            const yOffsetParam = { value: constr.yOffset, isExpr: typeof constr.yOffset === 'string' };
+                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: constr.mate2.flip,
+                                    reoriented: constr.mate2.reoriented,
+                                },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffset: zOffsetParam,
+                            });
                         }
                     }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
                     finally {
                         try {
                             if (constraints_1_1 && !constraints_1_1.done && (_a = constraints_1.return)) await _a.call(constraints_1);
                         }
-                        finally { if (e_1) throw e_1.error; }
+                        finally { if (e_3) throw e_3.error; }
                     }
                     await ccAPI.assemblyBuilder.updateFastenedConstraints(drawingId, constrToAdd);
                 },
@@ -656,7 +681,7 @@ export default class CAD {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                        await ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, constraintId, [rMatePath, rWcs1, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                        await ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, constraintId, { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
                         return constraintId;
                     }
                     return null;
@@ -667,36 +692,41 @@ export default class CAD {
                     const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                     const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
                     const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                    await ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, rConstrId, [rMatePath, rWcs1, mate1.flip, mate1.reoriented], xOffsetParam, yOffsetParam, zOffsetParam);
+                    await ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, rConstrId, { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
                 },
                 updateFastenedOriginConstraints: async (...constraints) => {
-                    var e_2, _a;
-                    const constrToAdd = [];
+                    var e_4, _a;
+                    const constraintsToAdd = [];
                     try {
                         for (var constraints_2 = __asyncValues(constraints), constraints_2_1; constraints_2_1 = await constraints_2.next(), !constraints_2_1.done;) {
                             const constr = constraints_2_1.value;
                             const [rConstrId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId));
                             const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
-                            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([
-                                rConstrId,
-                                [rMatePath, rWcs1, constr.mate1.flip, constr.mate1.reoriented],
-                                xOffsetParam,
-                                yOffsetParam,
-                                zOffsetParam,
-                            ]);
+                            const xOffsetParam = { value: constr.xOffset, isExpr: typeof constr.xOffset === 'string' };
+                            const yOffsetParam = { value: constr.yOffset, isExpr: typeof constr.yOffset === 'string' };
+                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
+                            constraintsToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffset: zOffsetParam,
+                            });
                         }
                     }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
                     finally {
                         try {
                             if (constraints_2_1 && !constraints_2_1.done && (_a = constraints_2.return)) await _a.call(constraints_2);
                         }
-                        finally { if (e_2) throw e_2.error; }
+                        finally { if (e_4) throw e_4.error; }
                     }
-                    await ccAPI.assemblyBuilder.updateFastenedOriginConstraints(drawingId, constrToAdd);
+                    await ccAPI.assemblyBuilder.updateFastenedOriginConstraints(drawingId, constraintsToAdd);
                 },
                 createBufferGeometry: async (objectId) => {
                     await this.queue;
@@ -737,12 +767,12 @@ export default class CAD {
                         const membersToAdd = [];
                         members.forEach(mem => {
                             const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
-                            const dataType = isExpr ? DataType.REAL : getDataType(mem.value); // TODO: Aktuell nur Real Werte als Expression
+                            const dataType = DataType.REAL; // TODO: Aktuell nur Real Werte als Expression
                             const featureAPIParam = {
                                 value: mem.value,
                                 isExpr: isExpr,
                             };
-                            membersToAdd.push([mem.name, featureAPIParam, dataType]);
+                            membersToAdd.push({ name: mem.name, value: featureAPIParam, dataType });
                         });
                         const success = featureAPI.updateExpressionSet(drawingId, rPartId, membersToAdd, [], []);
                         return success;
@@ -773,15 +803,7 @@ export default class CAD {
                 createWorkAxis: (partId, type, references, position, direction, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wAName = name ? name : 'WorkAxis';
-                        const wARefs = rReferences;
-                        const wAId = await featureAPI.createWorkAxis(drawingId, rPartId, {
-                            axisType: type,
-                            references: wARefs,
-                            name: wAName,
-                            position: position,
-                            direction: direction,
-                            local: local,
-                        });
+                        const wAId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkAxis, wAName);
                         if (wAId != null) {
                             const positionParam = {
                                 value: position,
@@ -791,7 +813,7 @@ export default class CAD {
                                 value: direction,
                                 isExpr: typeof direction === 'string',
                             };
-                            await featureAPI.updateWorkAxis(drawingId, wAId, type, wARefs, positionParam, directionParam, local);
+                            await featureAPI.updateWorkAxis(drawingId, wAId, type, rReferences, positionParam, directionParam, local);
                             return wAId;
                         }
                         return null;
@@ -800,24 +822,14 @@ export default class CAD {
                 createWorkCoordSystem: (partId, type, references, coordinateSystem, offset, rotation, inverted, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wCSName = name ? name : 'WorkCoordSystem';
-                        const wCSRefs = rReferences;
-                        const wCSId = await featureAPI.createWorkCoordSystem(drawingId, rPartId, {
-                            coordSystemType: type,
-                            name: wCSName,
-                            references: wCSRefs,
-                            coordinateSystem,
-                            offset,
-                            rotation,
-                            inverted,
-                            local,
-                        });
+                        const wCSId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkCoordSystem, wCSName);
                         if (wCSId != null) {
                             const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
                             const rotationParam = {
                                 value: rotation,
                                 isExpr: typeof rotation === 'string',
                             };
-                            await featureAPI.updateWorkCoordSystem(drawingId, wCSId, type, wCSRefs, coordinateSystem, offsetParam, rotationParam, inverted, local);
+                            await featureAPI.updateWorkCoordSystem(drawingId, wCSId, type, rReferences, coordinateSystem, offsetParam, rotationParam, inverted, local);
                             return wCSId;
                         }
                         return null;
@@ -826,16 +838,7 @@ export default class CAD {
                 createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wPName = name ? name : 'WorkPlane';
-                        const wPRefs = rReferences;
-                        const wPId = await featureAPI.createWorkPlane(drawingId, rPartId, {
-                            planeType: type,
-                            references: wPRefs,
-                            offsetOrAngle: offset,
-                            name: wPName,
-                            position: position,
-                            normal: normal,
-                            local: local,
-                        });
+                        const wPId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkPlane, wPName);
                         if (wPId != undefined) {
                             const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
                             const angleParam = { value: angle, isExpr: typeof angle === 'string' };
@@ -844,7 +847,7 @@ export default class CAD {
                                 isExpr: typeof position === 'string',
                             };
                             const normalParam = { value: normal, isExpr: typeof normal === 'string' };
-                            await featureAPI.updateWorkPlane(drawingId, wPId, type, wPRefs, offsetParam, angleParam, positionParam, normalParam, local);
+                            await featureAPI.updateWorkPlane(drawingId, wPId, type, rReferences, offsetParam, angleParam, positionParam, normalParam, local);
                             return wPId;
                         }
                         return null;
@@ -853,20 +856,13 @@ export default class CAD {
                 createWorkPoint: (partId, type, references, position, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wPTName = name ? name : 'WorkPoint';
-                        const wPTRefs = rReferences;
-                        const wPTId = await featureAPI.createWorkPoint(drawingId, rPartId, {
-                            pointType: type,
-                            references: wPTRefs,
-                            name: wPTName,
-                            position: position,
-                            local: local,
-                        });
+                        const wPTId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkPoint, wPTName);
                         if (wPTId != undefined) {
                             const positionParam = {
                                 value: position,
                                 isExpr: typeof position === 'string',
                             };
-                            await featureAPI.updateWorkPoint(drawingId, wPTId, type, wPTRefs, positionParam, local);
+                            await featureAPI.updateWorkPoint(drawingId, wPTId, type, rReferences, positionParam, local);
                             return wPTId;
                         }
                         return null;
@@ -1140,12 +1136,12 @@ export default class CAD {
                     return this.resolve(async ([rPartId]) => {
                         const membersToModify = [];
                         members.forEach(mem => {
-                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
+                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen Strings
                             const featureAPIParam = {
                                 value: mem.value,
-                                isExpr: isExpr,
+                                isExpr,
                             };
-                            membersToModify.push([mem.name, featureAPIParam]);
+                            membersToModify.push({ name: mem.name, value: featureAPIParam });
                         });
                         const success = featureAPI.updateExpressionSet(drawingId, rPartId, [], membersToModify, []);
                         return success;
@@ -1157,10 +1153,19 @@ export default class CAD {
                         rExprSets.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]]);
+                                const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen Strings
+                                const featureAPIParam = {
+                                    value: mem.value,
+                                    isExpr,
+                                };
+                                membersToModify.push({ name: mem.name, value: featureAPIParam });
+                            });
+                            exprSetsToSet.push({
+                                productId: exprSet.partId,
+                                toAddMembers: [],
+                                toModifyMembers: membersToModify,
+                                toDeleteList: [],
                             });
-                            exprSetsToSet.push([exprSet.partId, [], membersToModify, []]);
                         });
                         const success = await featureAPI.updateExpressionSets(drawingId, exprSetsToSet);
                         return success;

package/build/{solid.js → esm/solid.js}

@@ -302,7 +302,7 @@ export default class CAD {
                 },
                 load: (data) => {
                     return this.resolve(async () => {
-                        const productId = await solidAPI.load(drawingId, data, 'of1', true);
+                        const productId = await solidAPI.load(drawingId, data, 'ofb', true);
                         if (productId !== null) {
                             const drawing = getDrawing(drawingId);
                             const solids = drawing.structure.tree[productId].solids;
@@ -355,7 +355,7 @@ export default class CAD {
                 },
                 save: () => {
                     return this.resolve(async () => {
-                        return solidAPI.save(drawingId, 'of1');
+                        return solidAPI.save(drawingId, 'ofb');
                     });
                 },
                 scale: (target, pointOrFactor) => {