fluidcad 0.0.37 → 0.0.39

package/lib/dist/oc/wire-ops.d.ts

@@ -9,8 +9,34 @@ export declare class WireOps {
     static makeWireFromEdges(edges: Edge[]): Wire;
     static reverseWire(wire: Wire): Wire;
     static buildWire(edges: Edge[]): Wire;
-    static offsetWire(shape: Wire | Edge, distance: number, isOpen: boolean): Wire;
+    static offsetWire(shape: Wire | Edge, distance: number, isOpen: boolean, plane?: Plane): Wire;
+    /**
+     * Offsets a wire by `distance` on `plane`, handling open/closed wires and
+     * negative distances.
+     *
+     * The plane is passed as a reference face so BRepOffsetAPI_MakeOffset can
+     * resolve an offset direction even for wires with no curvature to imply a
+     * plane (e.g. a single straight segment, which otherwise fails outright).
+     *
+     * For open wires a negative distance offsets to the *opposite* side — the
+     * face-based offset does not flip sides on a sign change by itself, so the
+     * wire is reversed, offset by the magnitude, then reversed back. For closed
+     * wires the plane-less offset is tried first (the path circles rely on, where
+     * the sign selects inward/outward) and the face-based offset is the fallback.
+     */
+    static offsetWireOnPlane(wire: Wire, distance: number, isClosed: boolean, plane: Plane): Wire;
     static isCWRaw(wire: TopoDS_Wire, normal: Vector3d): boolean;
+    /**
+     * Groups edges into connected chains — one wire per chain — via
+     * `ShapeAnalysis_FreeBounds.ConnectEdgesToWires`. Edge ends within
+     * `tolerance` of each other connect; disconnected groups come back as
+     * separate wires (e.g. a guide sketch holding a curve and its mirror).
+     *
+     * V8-binding gotcha: the plain-name dispatcher can resolve to the
+     * deprecated out-parameter overload, which returns a `{ wires }` envelope
+     * instead of the sequence itself — unwrap at runtime.
+     */
+    static connectEdgesToWires(edges: Edge[], tolerance?: number): Wire[];
     static makeWireFromEdgesRaw(edges: TopoDS_Edge[]): TopoDS_Wire;
     static reverseWireRaw(wire: TopoDS_Wire): TopoDS_Wire;
     static buildWireRaw(edges: TopoDS_Edge[]): TopoDS_Wire;
@@ -31,5 +57,5 @@ export declare class WireOps {
     } | null;
     static groupConnectedEdges(edges: Edge[]): Edge[][];
     private static verticesMatch;
-    static offsetWireRaw(wire: TopoDS_Wire, distance: number, isOpen: boolean): TopoDS_Wire;
+    static offsetWireRaw(wire: TopoDS_Wire, distance: number, isOpen: boolean, plane?: Plane): TopoDS_Wire;
 }

package/lib/dist/oc/wire-ops.js

@@ -15,9 +15,39 @@ export class WireOps {
     static buildWire(edges) {
         return Wire.fromTopoDSWire(WireOps.buildWireRaw(edges.map(e => e.getShape())));
     }
-    static offsetWire(shape, distance, isOpen) {
+    static offsetWire(shape, distance, isOpen, plane) {
         const wire = shape instanceof Wire ? shape : WireOps.makeWireFromEdges([shape]);
-        return Wire.fromTopoDSWire(WireOps.offsetWireRaw(wire.getShape(), distance, isOpen));
+        return Wire.fromTopoDSWire(WireOps.offsetWireRaw(wire.getShape(), distance, isOpen, plane));
+    }
+    /**
+     * Offsets a wire by `distance` on `plane`, handling open/closed wires and
+     * negative distances.
+     *
+     * The plane is passed as a reference face so BRepOffsetAPI_MakeOffset can
+     * resolve an offset direction even for wires with no curvature to imply a
+     * plane (e.g. a single straight segment, which otherwise fails outright).
+     *
+     * For open wires a negative distance offsets to the *opposite* side — the
+     * face-based offset does not flip sides on a sign change by itself, so the
+     * wire is reversed, offset by the magnitude, then reversed back. For closed
+     * wires the plane-less offset is tried first (the path circles rely on, where
+     * the sign selects inward/outward) and the face-based offset is the fallback.
+     */
+    static offsetWireOnPlane(wire, distance, isClosed, plane) {
+        if (!isClosed) {
+            if (distance < 0) {
+                const reversed = WireOps.reverseWire(wire);
+                const offsetResult = WireOps.offsetWire(reversed, -distance, true, plane);
+                return WireOps.reverseWire(offsetResult);
+            }
+            return WireOps.offsetWire(wire, distance, true, plane);
+        }
+        try {
+            return WireOps.offsetWire(wire, distance, false);
+        }
+        catch {
+            return WireOps.offsetWire(wire, distance, false, plane);
+        }
     }
     static isCWRaw(wire, normal) {
         const oc = getOC();
@@ -40,6 +70,39 @@ export class WireOps {
         adaptor.delete();
         return signedArea < 0;
     }
+    /**
+     * Groups edges into connected chains — one wire per chain — via
+     * `ShapeAnalysis_FreeBounds.ConnectEdgesToWires`. Edge ends within
+     * `tolerance` of each other connect; disconnected groups come back as
+     * separate wires (e.g. a guide sketch holding a curve and its mirror).
+     *
+     * V8-binding gotcha: the plain-name dispatcher can resolve to the
+     * deprecated out-parameter overload, which returns a `{ wires }` envelope
+     * instead of the sequence itself — unwrap at runtime.
+     */
+    static connectEdgesToWires(edges, tolerance = 1e-6) {
+        const oc = getOC();
+        const input = new oc.NCollection_HSequence_TopoDS_Shape();
+        for (const edge of edges) {
+            input.Append(edge.getShape());
+        }
+        const result = oc.ShapeAnalysis_FreeBounds.ConnectEdgesToWires(input, tolerance, false);
+        const isEnvelope = result && typeof result.Sequence !== "function" && result.wires;
+        const handle = isEnvelope ? result.wires : result;
+        const wires = [];
+        const sequence = handle.Sequence();
+        for (let i = 1; i <= sequence.Length(); i++) {
+            wires.push(Wire.fromTopoDSWire(oc.TopoDS.Wire(sequence.Value(i))));
+        }
+        input.delete();
+        if (isEnvelope && typeof result[Symbol.dispose] === "function") {
+            result[Symbol.dispose]();
+        }
+        else if (typeof handle.delete === "function") {
+            handle.delete();
+        }
+        return wires;
+    }
     static makeWireFromEdgesRaw(edges) {
         const oc = getOC();
         const wireMaker = new oc.BRepBuilderAPI_MakeWire();
@@ -193,10 +256,31 @@ export class WireOps {
         const dz = p1.z - p2.z;
         return (dx * dx + dy * dy + dz * dz) < 1e-14;
     }
-    static offsetWireRaw(wire, distance, isOpen) {
+    static offsetWireRaw(wire, distance, isOpen, plane) {
         const oc = getOC();
         const maker = new oc.BRepOffsetAPI_MakeOffset();
-        maker.Init(oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
+        // BRepOffsetAPI_MakeOffset can't infer an offset direction from a wire with
+        // no curvature (e.g. a single straight segment), so the face-less Init
+        // fails with "Failed to offset wire". Initializing it with a planar
+        // reference face supplies the normal it needs — pass `plane` whenever the
+        // offset happens on a known sketch/target plane.
+        if (plane) {
+            const [pln, disposePlane] = Convert.toGpPln(plane);
+            const faceMaker = new oc.BRepBuilderAPI_MakeFace(pln);
+            if (!faceMaker.IsDone()) {
+                faceMaker.delete();
+                disposePlane();
+                maker.delete();
+                throw new Error("Failed to create reference face for wire offset");
+            }
+            const face = faceMaker.Face();
+            faceMaker.delete();
+            disposePlane();
+            maker.Init(face, oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
+        }
+        else {
+            maker.Init(oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
+        }
         maker.AddWire(wire);
         maker.Perform(distance, 0);
         if (!maker.IsDone()) {

package/lib/dist/oc/wrap-ops.js

@@ -4,6 +4,8 @@ import { Explorer } from "./explorer.js";
 import { FaceQuery } from "./face-query.js";
 import { WireOps } from "./wire-ops.js";
 import { ShapeFactory } from "../common/shape-factory.js";
+import { NCollections } from "./ncollection.js";
+import { Point2D } from "../math/point.js";
 import { ConeDevelopment, CylinderDevelopment, } from "./wrap-development.js";
 import { interpolateBSpline2d } from "../math/bspline-interpolation.js";
 /** Sample points per curved sketch edge before fitting its UV pcurve. */
@@ -284,22 +286,13 @@ export class WrapOps {
     static fitUvCurve(samples) {
         const oc = getOC();
         const data = interpolateBSpline2d(samples.map(s => ({ x: s.u, y: s.v })));
-        const poles = new oc.NCollection_Array1_gp_Pnt2d(1, data.poles.length);
-        for (let i = 0; i < data.poles.length; i++) {
-            const point = new oc.gp_Pnt2d(data.poles[i].x, data.poles[i].y);
-            poles.SetValue(i + 1, point);
-            point.delete();
-        }
-        const knots = new oc.NCollection_Array1_double(1, data.knots.length);
-        const multiplicities = new oc.NCollection_Array1_int(1, data.knots.length);
-        for (let i = 0; i < data.knots.length; i++) {
-            knots.SetValue(i + 1, data.knots[i]);
-            multiplicities.SetValue(i + 1, data.multiplicities[i]);
-        }
+        const [poles, disposePoles] = NCollections.toArray1Pnt2d(data.poles.map(p => new Point2D(p.x, p.y)));
+        const [knots, disposeKnots] = NCollections.toArray1Double(data.knots);
+        const [multiplicities, disposeMultiplicities] = NCollections.toArray1Int(data.multiplicities);
         const curve = new oc.Geom2d_BSplineCurve(poles, knots, multiplicities, data.degree);
-        poles.delete();
-        knots.delete();
-        multiplicities.delete();
+        disposePoles();
+        disposeKnots();
+        disposeMultiplicities();
         return curve;
     }
     /** Thickens the wrapped face along the surface normal into a solid. */

package/lib/dist/tests/features/2d/circle.test.js

@@ -51,14 +51,4 @@ describe("circle", () => {
             expect(getFacesByType(solid, "cylinder")).toHaveLength(1);
         });
     });
-    describe("standalone with targetPlane", () => {
-        it("should create a circle on a specific plane", () => {
-            circle("xy", 60);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            const bbox = ShapeOps.getBoundingBox(solid);
-            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
-        });
-    });
 });

package/lib/dist/tests/features/2d/ellipse.test.js

@@ -66,35 +66,5 @@ describe("ellipse", () => {
             render();
             expect(negEllipse?.getError()).toMatch(/positive/i);
         });
-        it("throws when given a plane inside a sketch", () => {
-            expect(() => {
-                sketch("xy", () => {
-                    ellipse("xy", 30, 20);
-                });
-                render();
-            }).toThrow();
-        });
-    });
-    describe("standalone with targetPlane", () => {
-        it("creates an ellipse on a specific plane", () => {
-            ellipse("xy", 60, 40);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            const bbox = ShapeOps.getBoundingBox(solid);
-            expect(bbox.maxX - bbox.minX).toBeCloseTo(120, 0);
-            expect(bbox.maxY - bbox.minY).toBeCloseTo(80, 0);
-        });
-        it("creates an ellipse on a plane at a given center", () => {
-            ellipse("xy", [10, 20], 30, 15);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            const bbox = ShapeOps.getBoundingBox(solid);
-            expect(bbox.centerX).toBeCloseTo(10, 0);
-            expect(bbox.centerY).toBeCloseTo(20, 0);
-            expect(bbox.maxX - bbox.minX).toBeCloseTo(60, 0);
-            expect(bbox.maxY - bbox.minY).toBeCloseTo(30, 0);
-        });
     });
 });

package/lib/dist/tests/features/2d/line.test.js

@@ -32,11 +32,6 @@ describe("line functions", () => {
             expect(bbox.maxX - bbox.minX).toBeCloseTo(80, 0);
             expect(bbox.maxY - bbox.minY).toBeCloseTo(40, 0);
         });
-        it("should support standalone mode with targetPlane", () => {
-            hLine("xy", 50);
-            render();
-            // Just verify no error — standalone line doesn't form a closed shape
-        });
     });
     describe("vLine", () => {
         it("should create a vertical line and form a closed rect", () => {

package/lib/dist/tests/features/2d/offset.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { setupOC, render } from "../../setup.js";
 import sketch from "../../../core/sketch.js";
-import { circle, hLine, vLine, offset } from "../../../core/2d/index.js";
+import { circle, hLine, vLine, aLine, line, offset } from "../../../core/2d/index.js";
 import { ShapeOps } from "../../../oc/shape-ops.js";
 describe("offset", () => {
     setupOC();
@@ -42,6 +42,79 @@ describe("offset", () => {
             expect(shapes.length).toBeGreaterThan(2);
         });
     });
+    // Regression: a single straight segment has no curvature to imply an offset
+    // plane, so BRepOffsetAPI_MakeOffset needs the sketch plane as a reference
+    // face. Without it, the offset failed with "Failed to offset wire" and no
+    // offset edge was produced.
+    describe("offset single open line", () => {
+        const endpoints = (edge) => [edge.getFirstVertex().toPoint(), edge.getLastVertex().toPoint()];
+        it("offsets a single hLine to a parallel line at the right distance", () => {
+            const s = sketch("xy", () => {
+                hLine(100);
+                offset(10);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBe(2);
+            const [a, b] = endpoints(shapes[1]);
+            expect(Math.abs(a.y)).toBeCloseTo(10, 6);
+            expect(Math.abs(b.y)).toBeCloseTo(10, 6);
+            expect(Math.hypot(b.x - a.x, b.y - a.y)).toBeCloseTo(100, 6);
+        });
+        it("offsets a single vLine to a parallel line at the right distance", () => {
+            const s = sketch("xy", () => {
+                vLine(100);
+                offset(10);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBe(2);
+            const [a, b] = endpoints(shapes[1]);
+            expect(Math.abs(a.x)).toBeCloseTo(10, 6);
+            expect(Math.abs(b.x)).toBeCloseTo(10, 6);
+            expect(Math.hypot(b.x - a.x, b.y - a.y)).toBeCloseTo(100, 6);
+        });
+        it("offsets a single aLine, preserving its length", () => {
+            const s = sketch("xy", () => {
+                aLine(30, 100);
+                offset(10);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBe(2);
+            const [a, b] = endpoints(shapes[1]);
+            expect(Math.hypot(b.x - a.x, b.y - a.y)).toBeCloseTo(100, 6);
+        });
+        it("offsets a single line, preserving its length", () => {
+            const s = sketch("xy", () => {
+                line([100, 50]);
+                offset(10);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBe(2);
+            const [a, b] = endpoints(shapes[1]);
+            expect(Math.hypot(b.x - a.x, b.y - a.y)).toBeCloseTo(Math.hypot(100, 50), 6);
+        });
+        it("offsets a single line to the opposite side with a negative distance", () => {
+            const sPos = sketch("xy", () => {
+                hLine(100);
+                offset(10);
+            });
+            render();
+            const posY = endpoints(sPos.getShapes()[1])[0].y;
+            const sNeg = sketch("xy", () => {
+                hLine(100);
+                offset(-10);
+            });
+            render();
+            const negShapes = sNeg.getShapes();
+            expect(negShapes.length).toBe(2);
+            const negY = endpoints(negShapes[1])[0].y;
+            expect(Math.abs(negY)).toBeCloseTo(10, 6);
+            expect(Math.sign(negY)).toBe(-Math.sign(posY));
+        });
+    });
     describe("offset direction", () => {
         it("positive and negative offsets should produce different results", () => {
             const s1 = sketch("xy", () => {
@@ -86,16 +159,6 @@ describe("offset", () => {
             expect(shapes).toHaveLength(1);
         });
     });
-    describe("specific targets (standalone)", () => {
-        it("should offset source geometries onto a target plane", () => {
-            const s = sketch("xy", () => {
-                circle(40);
-            });
-            offset("xy", 5, false, s);
-            render();
-            // Offset edges should exist on the target plane
-        });
-    });
     describe("default distance", () => {
         it("should use default distance of 1", () => {
             const s = sketch("xy", () => {

package/lib/dist/tests/features/2d/polygon.test.js

@@ -131,20 +131,4 @@ describe("polygon", () => {
             expect(bbox.centerY).toBeCloseTo(30, 0);
         });
     });
-    describe("standalone with targetPlane", () => {
-        it("should create a polygon on a specific plane", () => {
-            polygon("xy", 5, 50);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            expect(solid.getFaces()).toHaveLength(7);
-        });
-        it("should create a circumscribed polygon on a specific plane", () => {
-            polygon("xy", 6, 60, "circumscribed");
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            expect(solid.getFaces()).toHaveLength(8);
-        });
-    });
 });

package/lib/dist/tests/features/2d/rect.test.js

@@ -52,15 +52,4 @@ describe("rect", () => {
             expect(solid.getEdges().length).toBeGreaterThan(12);
         });
     });
-    describe("standalone with targetPlane", () => {
-        it("should create a rectangle on a specific plane", () => {
-            rect("xy", 80, 40);
-            const e = extrude(10);
-            render();
-            const solid = e.getShapes()[0];
-            const bbox = ShapeOps.getBoundingBox(solid);
-            expect(bbox.maxX - bbox.minX).toBeCloseTo(80, 0);
-            expect(bbox.maxY - bbox.minY).toBeCloseTo(40, 0);
-        });
-    });
 });

package/lib/dist/tests/features/2d/slot.test.js

@@ -33,12 +33,4 @@ describe("slot", () => {
             expect(arcEdges.length).toBeGreaterThan(0);
         });
     });
-    describe("standalone with targetPlane", () => {
-        it("should create a slot on a specific plane", () => {
-            slot("xy", 60, 10);
-            const e = extrude(10);
-            render();
-            expect(e.getShapes()).toHaveLength(1);
-        });
-    });
 });

package/lib/dist/tests/features/fillet2d.test.js

@@ -4,7 +4,7 @@ import sketch from "../../core/sketch.js";
 import extrude from "../../core/extrude.js";
 import fillet from "../../core/fillet.js";
 import fuse from "../../core/fuse.js";
-import { hMove, rect } from "../../core/2d/index.js";
+import { arc, hMove, rect, vLine, hLine, vMove, back } from "../../core/2d/index.js";
 import { getEdgesByType } from "../utils.js";
 describe("fillet2d", () => {
     setupOC();
@@ -51,6 +51,42 @@ describe("fillet2d", () => {
             // 4 shortened sides per face (8) + 4 vertical edges each split into segments (8) = 16
             expect(getEdgesByType(solid, "line")).toHaveLength(16);
         });
+        it("should fillet a corner passed as radius-first spread args", () => {
+            const s = sketch("xy", () => {
+                const l1 = hLine(40);
+                const l2 = vLine(-40);
+                fillet(8, l1, l2);
+            });
+            render();
+            // The corner is rounded: each line is shortened and one fillet arc inserted.
+            // Before the radius-first spread dispatch existed, fillet(8, l1, l2) was a
+            // silent no-op (returned undefined) and produced 0 arcs.
+            expect(getEdgesByType(s.getEdges(), "arc")).toHaveLength(1);
+            expect(getEdgesByType(s.getEdges(), "line")).toHaveLength(2);
+        });
+        it("fillets an arc/line corner passed as radius-first spread args", () => {
+            // The exact shape from the original bug report: a fillet between an arc (l1)
+            // and a line (l2) requested as fillet(radius, l2, l1). Before the radius-first
+            // spread form was dispatched, this was a silent no-op while fillet(8) (all
+            // corners) rounded the same arc/line corner.
+            const s = sketch("front", () => {
+                vMove(10);
+                const gl = hLine(140).guide().centered();
+                back();
+                vMove(33 + 16);
+                hLine(8);
+                vLine(-16);
+                hLine(15 - 8);
+                const l1 = arc(gl.end()).radius(55);
+                const l2 = vLine(-10);
+                fillet(8, l2, l1);
+            });
+            render();
+            // Baseline (no fillet) is 1 arc; rounding the arc/line corner shortens the
+            // original arc and inserts the fillet arc -> 2 arcs. The array form
+            // fillet([l2, l1], 8) produces the identical result.
+            expect(getEdgesByType(s.getEdges(), "arc")).toHaveLength(2);
+        });
     });
     describe("fillet radius", () => {
         it("should use default radius of 1", () => {

package/lib/dist/tests/features/loft-conditions.test.d.ts

@@ -0,0 +1 @@
+export {};