onshape 0.1.4 → 0.2.0

package/dist/builders/advanced.js

@@ -0,0 +1,372 @@
+"use strict";
+// Advanced feature builders for Onshape — fillet, chamfer, shell, draft, revolve,
+// boolean, mirror, patterns, offset-plane, and assembly mate/connector/group.
+// 1:1 port of onshape_cli/builders/advanced.py.
+//
+// Every builder emits the standard BTFeatureDefinitionCall-1406 envelope the
+// POST .../features endpoint expects. Selection is query-string based so it
+// survives topology changes; explicit deterministic IDs are also supported.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qBodyOfFeature = exports.qAllBodies = exports.qCircularEdges = exports.qEdgesOfFeature = exports.qAllEdges = void 0;
+exports.featureCall = featureCall;
+exports.pQuery = pQuery;
+exports.pSketchRegion = pSketchRegion;
+exports.pQuantity = pQuantity;
+exports.pEnum = pEnum;
+exports.pBool = pBool;
+exports.buildFillet = buildFillet;
+exports.buildChamfer = buildChamfer;
+exports.buildShell = buildShell;
+exports.buildDraft = buildDraft;
+exports.buildRevolveAxis = buildRevolveAxis;
+exports.buildBoolean = buildBoolean;
+exports.buildMirror = buildMirror;
+exports.buildLinearPattern = buildLinearPattern;
+exports.buildCircularPattern = buildCircularPattern;
+exports.buildOffsetPlaneSelect = buildOffsetPlaneSelect;
+exports.buildAssemblyMate = buildAssemblyMate;
+exports.buildAssemblyMateConnector = buildAssemblyMateConnector;
+exports.buildAssemblyGroup = buildAssemblyGroup;
+// --- Low-level parameter helpers -------------------------------------------
+function featureCall(featureType, name, parameters, namespace = "") {
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMFeature-134",
+            featureType,
+            name,
+            suppressed: false,
+            namespace,
+            parameters,
+        },
+    };
+}
+function pQuery(parameterId, opts = {}) {
+    const query = {
+        btType: "BTMIndividualQuery-138",
+        deterministicIds: opts.deterministicIds ?? [],
+    };
+    if (opts.queryString) {
+        query.queryStatement = null;
+        query.queryString = opts.queryString;
+    }
+    if (opts.featureId)
+        query.featureId = opts.featureId;
+    return {
+        btType: "BTMParameterQueryList-148",
+        queries: [query],
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function pSketchRegion(parameterId, sketchFeatureId) {
+    return {
+        btType: "BTMParameterQueryList-148",
+        queries: [
+            {
+                btType: "BTMIndividualSketchRegionQuery-140",
+                queryStatement: null,
+                filterInnerLoops: true,
+                queryString: `query = qSketchRegion(id + "${sketchFeatureId}", true);`,
+                featureId: sketchFeatureId,
+                deterministicIds: [],
+            },
+        ],
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function pQuantity(parameterId, value, units = "in", opts = {}) {
+    let expression;
+    if (opts.variable)
+        expression = `#${opts.variable}`;
+    else if (opts.isInteger)
+        expression = `${Math.trunc(value)}`;
+    else if (units)
+        expression = `${value} ${units}`;
+    else
+        expression = `${value}`;
+    return {
+        btType: "BTMParameterQuantity-147",
+        isInteger: opts.isInteger ?? false,
+        value,
+        units: "",
+        expression,
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function pEnum(parameterId, enumName, value) {
+    return {
+        btType: "BTMParameterEnum-145",
+        namespace: "",
+        enumName,
+        value,
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function pBool(parameterId, value) {
+    return {
+        btType: "BTMParameterBoolean-144",
+        value,
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+// --- Reusable selection query strings --------------------------------------
+const qAllEdges = () => "query = qOwnedByBody(qAllModifiableSolidBodies(), EntityType.EDGE);";
+exports.qAllEdges = qAllEdges;
+const qEdgesOfFeature = (featureId) => `query = qCreatedBy(makeId("${featureId}"), EntityType.EDGE);`;
+exports.qEdgesOfFeature = qEdgesOfFeature;
+const qCircularEdges = () => "query = qGeometry(qOwnedByBody(qAllModifiableSolidBodies(), EntityType.EDGE), GeometryType.CIRCLE);";
+exports.qCircularEdges = qCircularEdges;
+const qAllBodies = () => "query = qAllModifiableSolidBodies();";
+exports.qAllBodies = qAllBodies;
+const qBodyOfFeature = (featureId) => `query = qCreatedBy(makeId("${featureId}"), EntityType.BODY);`;
+exports.qBodyOfFeature = qBodyOfFeature;
+function resolveEntityQuery(parameterId, sel, entity = "EDGE") {
+    if (sel.edgeIds && sel.edgeIds.length)
+        return pQuery(parameterId, { deterministicIds: sel.edgeIds });
+    if (sel.queryString)
+        return pQuery(parameterId, { queryString: sel.queryString });
+    if (sel.featureId) {
+        const qs = entity === "EDGE" ? (0, exports.qEdgesOfFeature)(sel.featureId) : (0, exports.qBodyOfFeature)(sel.featureId);
+        return pQuery(parameterId, { queryString: qs });
+    }
+    if (sel.circular)
+        return pQuery(parameterId, { queryString: (0, exports.qCircularEdges)() });
+    if (sel.selectAll)
+        return pQuery(parameterId, { queryString: (0, exports.qAllEdges)() });
+    throw new Error("No selection: pass edges, query, feature, --all, or --circular");
+}
+// --- Feature builders ------------------------------------------------------
+function buildFillet(opts) {
+    const entities = resolveEntityQuery("entities", opts);
+    return featureCall("fillet", opts.name ?? "Fillet", [
+        entities,
+        pQuantity("radius", opts.radius ?? 0.1, "in", { variable: opts.radiusVariable }),
+        pEnum("filletType", "FilletType", opts.filletType ?? "EDGE"),
+    ]);
+}
+function buildChamfer(opts) {
+    const entities = resolveEntityQuery("entities", opts);
+    const chamferType = opts.chamferType ?? "EQUAL_OFFSETS";
+    const params = [
+        entities,
+        pEnum("chamferType", "ChamferType", chamferType),
+        pQuantity("width", opts.width ?? 0.1, "in", { variable: opts.widthVariable }),
+    ];
+    if (chamferType === "OFFSET_ANGLE" && opts.angle !== undefined) {
+        params.push(pQuantity("angle", opts.angle, "deg"));
+    }
+    return featureCall("chamfer", opts.name ?? "Chamfer", params);
+}
+function buildShell(opts) {
+    let entities;
+    if (opts.faceIds && opts.faceIds.length)
+        entities = pQuery("entities", { deterministicIds: opts.faceIds });
+    else if (opts.queryString)
+        entities = pQuery("entities", { queryString: opts.queryString });
+    else
+        entities = pQuery("entities", { deterministicIds: [] });
+    const inward = opts.inward ?? true;
+    return featureCall("shell", opts.name ?? "Shell", [
+        entities,
+        pQuantity("thickness", opts.thickness ?? 0.125, "in", { variable: opts.thicknessVariable }),
+        pBool("oppositeDirection", !inward),
+    ]);
+}
+function buildDraft(opts) {
+    return featureCall("draft", opts.name ?? "Draft", [
+        pQuery("neutralPlane", { queryString: opts.neutralPlaneQuery }),
+        pQuery("draftFaces", { queryString: opts.faceQuery }),
+        pQuantity("angle", opts.angle ?? 3.0, "deg"),
+        pBool("oppositeDirection", false),
+    ]);
+}
+function buildRevolveAxis(opts) {
+    const axis = opts.axisIds && opts.axisIds.length
+        ? pQuery("axis", { deterministicIds: opts.axisIds })
+        : pQuery("axis", { queryString: opts.axisQuery });
+    const full = (opts.revolveType ?? "FULL") === "FULL";
+    const params = [
+        pEnum("bodyType", "ExtendedToolBodyType", "SOLID"),
+        pEnum("operationType", "NewBodyOperationType", opts.operationType ?? "NEW"),
+        pSketchRegion("entities", opts.sketchFeatureId),
+        axis,
+        pBool("fullRevolve", full),
+    ];
+    if (!full) {
+        params.push(pEnum("endBound", "RevolveBoundingType", "BLIND"));
+        params.push(pQuantity("angle", opts.angle ?? 360.0, "deg"));
+    }
+    params.push(pBool("defaultScope", true));
+    return featureCall("revolve", opts.name ?? "Revolve", params);
+}
+function buildBoolean(opts) {
+    const operationType = opts.operationType ?? "UNION";
+    let tools;
+    if (opts.toolIds && opts.toolIds.length)
+        tools = pQuery("tools", { deterministicIds: opts.toolIds });
+    else if (opts.toolsQuery)
+        tools = pQuery("tools", { queryString: opts.toolsQuery });
+    else
+        tools = pQuery("tools", { queryString: (0, exports.qAllBodies)() });
+    const params = [
+        pEnum("operationType", "BooleanOperationType", operationType),
+        pBool("defaultScope", false),
+        tools,
+        pBool("toolsExplicit", true),
+    ];
+    if (operationType === "SUBTRACTION") {
+        params.push(pBool("targetsAndToolsNeedGrouping", false));
+        if (opts.targetsQuery)
+            params.push(pQuery("targets", { queryString: opts.targetsQuery }));
+    }
+    return featureCall("booleanBodies", opts.name ?? "Boolean", params);
+}
+function buildMirror(opts) {
+    let plane;
+    if (opts.mirrorPlaneIds && opts.mirrorPlaneIds.length)
+        plane = pQuery("mirrorPlane", { deterministicIds: opts.mirrorPlaneIds });
+    else if (opts.mirrorPlaneQuery)
+        plane = pQuery("mirrorPlane", { queryString: opts.mirrorPlaneQuery });
+    else
+        throw new Error("Provide --plane-ids or --plane-query");
+    return featureCall("mirror", opts.name ?? "Mirror", [
+        pEnum("patternType", "MirrorType", opts.patternType ?? "PART"),
+        pEnum("operationType", "NewBodyOperationType", "NEW"),
+        pQuery("entities", { queryString: opts.entitiesQuery }),
+        plane,
+    ]);
+}
+function buildLinearPattern(opts) {
+    const direction = opts.directionIds && opts.directionIds.length
+        ? pQuery("directionOne", { deterministicIds: opts.directionIds })
+        : pQuery("directionOne", { queryString: opts.directionQuery });
+    return featureCall("linearPattern", opts.name ?? "Linear Pattern", [
+        pEnum("patternType", "PatternType", opts.patternType ?? "PART"),
+        pEnum("operationType", "NewBodyOperationType", "NEW"),
+        pQuery("entities", { queryString: opts.entitiesQuery }),
+        direction,
+        pBool("oppositeDirection", opts.opposite ?? false),
+        pQuantity("distance", opts.distance),
+        pQuantity("instanceCount", opts.instanceCount, "", { isInteger: true }),
+        pBool("hasSecondDir", false),
+    ]);
+}
+function buildCircularPattern(opts) {
+    const axis = opts.axisIds && opts.axisIds.length
+        ? pQuery("axis", { deterministicIds: opts.axisIds })
+        : pQuery("axis", { queryString: opts.axisQuery });
+    return featureCall("circularPattern", opts.name ?? "Circular Pattern", [
+        pEnum("patternType", "PatternType", opts.patternType ?? "PART"),
+        pEnum("operationType", "NewBodyOperationType", "NEW"),
+        pQuery("entities", { queryString: opts.entitiesQuery }),
+        axis,
+        pQuantity("angle", opts.angle ?? 360.0, "deg"),
+        pQuantity("instanceCount", opts.instanceCount, "", { isInteger: true }),
+        pBool("equalSpace", opts.equalSpacing ?? true),
+    ]);
+}
+function buildOffsetPlaneSelect(opts) {
+    let base;
+    if (opts.basePlaneIds && opts.basePlaneIds.length)
+        base = pQuery("entities", { deterministicIds: opts.basePlaneIds });
+    else if (opts.basePlaneQuery)
+        base = pQuery("entities", { queryString: opts.basePlaneQuery });
+    else
+        base = pQuery("entities", { deterministicIds: ["JCC"] }); // Front
+    return featureCall("cPlane", opts.name ?? "Plane", [
+        pEnum("cplaneType", "CPlaneType", "OFFSET"),
+        base,
+        pQuantity("offset", opts.offset ?? 1.0),
+        pBool("oppositeDirection", false),
+    ]);
+}
+// --- Assembly feature builders (posted to the assembly /features endpoint) --
+function buildAssemblyMate(opts) {
+    const queries = opts.mateConnectorIds.map((fid) => ({
+        btType: "BTMFeatureQueryWithOccurrence-157",
+        path: [],
+        featureId: fid,
+        queryData: "",
+    }));
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMMate-64",
+            featureType: "mate",
+            name: opts.name ?? "Mate",
+            suppressed: false,
+            parameters: [
+                pEnum("mateType", "Mate type", opts.mateType ?? "FASTENED"),
+                {
+                    btType: "BTMParameterQueryWithOccurrenceList-67",
+                    queries,
+                    parameterId: "mateConnectorsQuery",
+                },
+            ],
+        },
+    };
+}
+function buildAssemblyMateConnector(opts) {
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMMateConnector-66",
+            featureType: "mateConnector",
+            name: opts.name ?? "Mate connector",
+            suppressed: false,
+            parameters: [
+                {
+                    btType: "BTMParameterEnum-145",
+                    enumName: "Origin type",
+                    value: "ON_ENTITY",
+                    parameterId: "originType",
+                    namespace: "",
+                },
+                {
+                    btType: "BTMParameterQueryWithOccurrenceList-67",
+                    parameterId: "originQuery",
+                    queries: [
+                        {
+                            btType: "BTMInferenceQueryWithOccurrence-1083",
+                            inferenceType: opts.inferenceType ?? "CENTROID",
+                            path: [opts.occurrenceId],
+                            deterministicIds: [],
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+}
+function buildAssemblyGroup(opts) {
+    const queries = opts.occurrenceIds.map((oid) => ({
+        btType: "BTMIndividualOccurrenceQuery-626",
+        path: [oid],
+    }));
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMMateGroup-65",
+            featureType: "mateGroup",
+            name: opts.name ?? "Group",
+            suppressed: false,
+            parameters: [
+                {
+                    btType: "BTMParameterQueryWithOccurrenceList-67",
+                    queries,
+                    parameterId: "occurrencesQuery",
+                },
+            ],
+        },
+    };
+}

package/dist/builders/modeling.js

@@ -6,6 +6,10 @@ exports.buildCircleSketch = buildCircleSketch;
 exports.buildCircleAxisSketch = buildCircleAxisSketch;
 exports.buildCandyCanePathSketch = buildCandyCanePathSketch;
 exports.buildExtrude = buildExtrude;
+exports.buildThicken = buildThicken;
+exports.buildSketchFromEntities = buildSketchFromEntities;
+exports.buildRectangleSketch = buildRectangleSketch;
+exports.buildLineSketch = buildLineSketch;
 exports.buildRevolve = buildRevolve;
 exports.buildOffsetPlane = buildOffsetPlane;
 exports.buildSweep = buildSweep;
@@ -32,7 +36,7 @@ function parsePoint2(value) {
 function toMeters(value) {
     return value * INCH_TO_METER;
 }
-function circleEntity(id, center, radius) {
+function circleEntity(id, center, radius, isConstruction = false) {
     return {
         btType: "BTMSketchCurve-4",
         entityId: id,
@@ -46,9 +50,24 @@ function circleEntity(id, center, radius) {
             yDir: 0,
             clockwise: false,
         },
-        isConstruction: false,
+        isConstruction,
     };
 }
+function rectangleEntities(prefix, corner1, corner2) {
+    const [x1, y1] = corner1;
+    const [x2, y2] = corner2;
+    const corners = [
+        [x1, y1],
+        [x2, y1],
+        [x2, y2],
+        [x1, y2],
+    ];
+    const segments = [];
+    for (let i = 0; i < 4; i += 1) {
+        segments.push(lineEntity(`${prefix}.${i}`, corners[i], corners[(i + 1) % 4]));
+    }
+    return segments;
+}
 function lineEntity(id, start, end, isConstruction = false) {
     const x1 = toMeters(start[0]);
     const y1 = toMeters(start[1]);
@@ -236,6 +255,20 @@ function buildCandyCanePathSketch(input) {
     }
     return sketch(input.name, planeId(input.plane), entities);
 }
+function depthQuantity(parameterId, value, variable) {
+    if (!variable)
+        return pQuantity(parameterId, value, "in");
+    return {
+        btType: "BTMParameterQuantity-147",
+        isInteger: false,
+        value,
+        units: "",
+        expression: `#${variable}`,
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
 function buildExtrude(input) {
     return {
         btType: "BTFeatureDefinitionCall-1406",
@@ -248,13 +281,69 @@ function buildExtrude(input) {
             parameters: [
                 sketchRegion("entities", input.sketchFeatureId),
                 pEnum("operationType", "NewBodyOperationType", input.operationType),
-                pQuantity("depth", input.depth, "in"),
+                depthQuantity("depth", input.depth, input.depthVariable),
                 pBool("oppositeDirection", false),
                 pBool("defaultScope", true),
             ],
         },
     };
 }
+/** thicken — mirrors onshape_cli/builders/thicken.py (bare BTMFeature-134). */
+function buildThicken(input) {
+    const expression = input.thicknessVariable ? `#${input.thicknessVariable}` : `${input.thickness} in`;
+    return {
+        btType: "BTMFeature-134",
+        name: input.name,
+        suppressed: false,
+        namespace: "",
+        featureType: "thicken",
+        parameters: [
+            { btType: "BTMParameterEnum-145", enumName: "NewBodyOperationType", value: input.operationType, parameterId: "operationType" },
+            sketchRegion("entities", input.sketchFeatureId),
+            { btType: "BTMParameterBoolean-144", value: input.midplane ?? false, parameterId: "midplane" },
+            { btType: "BTMParameterQuantity-147", expression, parameterId: "thickness1" },
+            { btType: "BTMParameterBoolean-144", value: input.opposite ?? false, parameterId: "oppositeDirection" },
+            { btType: "BTMParameterQuantity-147", expression: "0 in", parameterId: "thickness2" },
+        ],
+    };
+}
+/** Generic sketch from a parsed entity list (create-sketch). Matches the
+ *  Python contract: types line/circle/rectangle (arc is not supported). */
+function buildSketchFromEntities(input) {
+    const out = [];
+    input.entities.forEach((entity, index) => {
+        const type = String(entity.type ?? "");
+        const construction = Boolean(entity.construction);
+        if (type === "line") {
+            out.push(lineEntity(`e${index}`, point(entity.start), point(entity.end), construction));
+        }
+        else if (type === "circle") {
+            out.push(circleEntity(`e${index}`, point(entity.center), Number(entity.radius), construction));
+        }
+        else if (type === "rectangle") {
+            out.push(...rectangleEntities(`e${index}`, point(entity.corner1), point(entity.corner2)));
+        }
+        else if (type === "arc") {
+            throw new Error("arc entities not supported by this sketch builder yet; use line/circle/rectangle");
+        }
+        else {
+            throw new Error(`Unknown sketch entity type '${type}'. Use line, circle, or rectangle.`);
+        }
+    });
+    return sketch(input.name, planeId(input.plane), out);
+}
+function buildRectangleSketch(input) {
+    return sketch(input.name, planeId(input.plane), rectangleEntities("rect", input.corner1, input.corner2));
+}
+function buildLineSketch(input) {
+    return sketch(input.name, planeId(input.plane), [lineEntity("line.1", input.start, input.end)]);
+}
+function point(value) {
+    if (Array.isArray(value) && value.length === 2 && value.every((v) => Number.isFinite(Number(v)))) {
+        return [Number(value[0]), Number(value[1])];
+    }
+    throw new Error(`Expected a [x, y] point; got ${JSON.stringify(value)}`);
+}
 function buildRevolve(input) {
     return {
         btType: "BTFeatureDefinitionCall-1406",