fluidcad 0.0.37 → 0.0.39

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

@@ -5,6 +5,7 @@ import extrude from "../../core/extrude.js";
 import shell from "../../core/shell.js";
 import fillet from "../../core/fillet.js";
 import rib from "../../core/rib.js";
+import plane from "../../core/plane.js";
 import { rect, circle, move, aLine, hLine } from "../../core/2d/index.js";
 import { Rib } from "../../features/rib.js";
 import { ShapeOps } from "../../oc/shape-ops.js";
@@ -277,6 +278,55 @@ describe("rib", () => {
                 expect(cVol / origVol).toBeLessThan(1.3);
             }
         });
+        it("repeat mirror keeps the parallel rib on the correct side", async () => {
+            const repeatModule = await import("../../core/repeat.js");
+            const repeat = repeatModule.default;
+            // Box centered on the origin and symmetric across the front (XZ) plane,
+            // so mirroring across "front" (Y → −Y) maps the scope onto itself. The
+            // correctly-mirrored rib is then congruent to the original reflected in
+            // Y only — its X and Z position are unchanged.
+            sketch("top", () => {
+                rect(100, 100).centered();
+            });
+            const box = extrude(60);
+            const s = shell(-4, box.endFaces());
+            // Diagonal spine on an offset front plane (Y = 20), placed off-centre in
+            // the XZ plane so that a flipped in-plane extrude direction would throw
+            // the rib to a clearly different X/Z position.
+            sketch(plane("front", 20), () => {
+                move([-30, 10]);
+                aLine(45, 25);
+            });
+            const r = rib(5).parallel().new().scope(s).extend();
+            repeat("mirror", "front", r);
+            render();
+            const bboxCenter = (shape) => {
+                const bb = ShapeOps.getBoundingBox(shape);
+                return {
+                    x: (bb.minX + bb.maxX) / 2,
+                    y: (bb.minY + bb.maxY) / 2,
+                    z: (bb.minZ + bb.maxZ) / 2,
+                };
+            };
+            expect(r.getShapes().length).toBeGreaterThan(0);
+            const orig = bboxCenter(r.getShapes()[0]);
+            const sceneMod = await import("../../scene-manager.js");
+            const scene = sceneMod.getCurrentScene();
+            const ribClones = scene.getSceneObjects().filter(o => o instanceof Rib && o !== r &&
+                o.getCloneSource() === r);
+            expect(ribClones.length).toBe(1);
+            const clone = ribClones[0];
+            expect(clone.getShapes().length).toBeGreaterThan(0);
+            const cl = bboxCenter(clone.getShapes()[0]);
+            // Mirroring across the front (XZ) plane flips Y only: the in-plane (X, Z)
+            // position must be preserved. Before the fix the clone's perpendicular
+            // extrude direction was negated (a cross product is a pseudovector under
+            // reflection), throwing the rib to the opposite side — its X/Z centre
+            // lands far from the original.
+            expect(Math.abs(cl.x - orig.x)).toBeLessThan(1);
+            expect(Math.abs(cl.z - orig.z)).toBeLessThan(1);
+            expect(Math.abs(cl.y + orig.y)).toBeLessThan(1);
+        });
         it("extended rib in .new() mode unifies coplanar artifact faces", () => {
             // The slab clips and scope cut leave coplanar sub-faces and seam edges
             // on flat walls of the rib. UnifySameDomain post-pass should merge

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

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { setupOC, render, addToScene } from "../setup.js";
 import sketch from "../../core/sketch.js";
 import extrude from "../../core/extrude.js";
@@ -8,6 +8,7 @@ import cylinder from "../../core/cylinder.js";
 import { rect } from "../../core/2d/index.js";
 import { Shell } from "../../features/shell.js";
 import { countShapes } from "../utils.js";
+import { ShellOps } from "../../oc/shell-ops.js";
 import { ShapeProps } from "../../oc/props.js";
 import { face } from "../../filters/index.js";
 describe("shell", () => {
@@ -263,4 +264,37 @@ describe("shell", () => {
             expect(sel2.getShapes()).toHaveLength(0);
         });
     });
+    describe("failure surfacing", () => {
+        it("flags an error instead of silently serving the original solid when the offset fails", () => {
+            // OCCT's MakeThickSolid throws on geometry it cannot hollow (a wall
+            // thicker than a nearby feature, a cut opening onto a removed face,
+            // etc.). Force that failure deterministically and assert the feature
+            // surfaces it rather than swallowing it into a silent no-op.
+            const spy = vi.spyOn(ShellOps, "makeThickSolid").mockImplementation(() => {
+                throw new Error("Failed to create thick solid.");
+            });
+            try {
+                sketch("xy", () => {
+                    rect(100, 100);
+                });
+                extrude(50);
+                select(face().onPlane("xy", 50));
+                const s = shell(5);
+                const scene = render();
+                // The failure is now visible to the user instead of being swallowed.
+                expect(s.getError()).toBeTruthy();
+                expect(s.getError()).toContain("shell");
+                // The original solid is preserved (downstream features still have
+                // geometry) — the no-op fallback is intact, just no longer silent.
+                const solid = scene.getAllSceneObjects()
+                    .flatMap(o => o.getShapes())
+                    .find(sh => sh.getType() === "solid");
+                expect(solid).toBeDefined();
+                expect(ShapeProps.getProperties(solid.getShape()).volumeMm3).toBeCloseTo(100 * 100 * 50, 1);
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+    });
 });

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

@@ -5,7 +5,8 @@ import sweep from "../../core/sweep.js";
 import extrude from "../../core/extrude.js";
 import helix from "../../core/helix.js";
 import cylinder from "../../core/cylinder.js";
-import { circle, rect, vLine, hLine, arc, move, hMove } from "../../core/2d/index.js";
+import plane from "../../core/plane.js";
+import { circle, rect, vLine, hLine, arc, line, move, hMove } from "../../core/2d/index.js";
 import { countShapes } from "../utils.js";
 import { ShapeOps } from "../../oc/shape-ops.js";
 import { ShapeProps } from "../../oc/props.js";
@@ -433,4 +434,129 @@ describe("sweep", () => {
             expect(vol).toBeLessThan(CYL_VOL - 100);
         });
     });
+    describe("helix thread sweep (asymmetric profile)", () => {
+        // An asymmetric profile swept along a helix is the case that exposes
+        // section twist — a rotationally symmetric circle (used by the tests above)
+        // looks identical no matter how the section spins, so it can't catch a
+        // wobbling trihedron. This sweeps a thread-like trapezoid drawn on a plane
+        // built off the helix (plane(h)), the orientation a user reaches for.
+        //
+        // The fixed binormal must track the helix axis. With the wrong binormal the
+        // section flips ~twice per turn, producing a self-intersecting ribbon whose
+        // mass piles up on one side (centroid leaves the axis) and whose volume
+        // collapses to a fraction of the real thread. For a whole number of turns a
+        // correct thread is axisymmetric: its centroid sits on the coil axis.
+        it("produces a clean axisymmetric coil, not a wobbling ribbon", () => {
+            const h = helix("z").height(80).radius(25).pitch(10); // 8 full turns
+            const p = plane(h);
+            const profile = sketch(p, () => {
+                line([3, 0], [-3, 0]);
+                line([-2, -6]);
+                line([2, -6]);
+                line([3, 0]);
+            });
+            const s = sweep(h, profile);
+            render();
+            expect(s.getError()).toBeNull();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            const props = ShapeProps.getProperties(shapes[0].getShape());
+            // Centroid on the coil (Z) axis — a wobbling ribbon piled it out at the
+            // ~25mm coil radius instead.
+            const radialOffset = Math.hypot(props.centroid.x, props.centroid.y);
+            expect(radialOffset).toBeLessThan(1);
+            expect(props.centroid.z).toBeCloseTo(40, 0);
+            // Real thread volume ≈ profile area (30mm²) × coil length (~1260mm).
+            // The wobble collapsed this to ~1500mm³; a section that collapses toward
+            // the axis (wrong trihedron the other way) drops it to a few thousand.
+            expect(props.volumeMm3).toBeGreaterThan(25000);
+            expect(props.volumeMm3).toBeLessThan(40000);
+            // The coil sits at the helix radius (~25mm), not collapsed onto the axis.
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            const radialExtent = Math.max(bbox.maxX - bbox.minX, bbox.maxY - bbox.minY) / 2;
+            expect(radialExtent).toBeGreaterThan(23);
+            expect(radialExtent).toBeLessThan(30);
+        });
+    });
+    describe("extend", () => {
+        it("extends the run-out past the path end along the tangent", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile).extend("end", 20);
+            render();
+            expect(s.getError()).toBeNull();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            // Straight Z sweep with flat caps: Z extent = path length + extension.
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(70, 0);
+        });
+        it("extends the lead-in before the path start along the tangent", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile).extend("start", 20);
+            render();
+            expect(s.getError()).toBeNull();
+            const bbox = ShapeOps.getBoundingBox(s.getShapes()[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(70, 0);
+        });
+        it("extends both ends when chained", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile).extend("start", 10).extend("end", 20);
+            render();
+            expect(s.getError()).toBeNull();
+            const bbox = ShapeOps.getBoundingBox(s.getShapes()[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(80, 0);
+        });
+        it("adds volume proportional to the extension length", () => {
+            const profile = sketch("xy", () => {
+                circle(10); // diameter 10 ⇒ radius 5 ⇒ area 25π
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile).extend("end", 30);
+            render();
+            // Right cylinder: π·5²·(50 + 30).
+            const vol = ShapeProps.getProperties(s.getShapes()[0].getShape()).volumeMm3;
+            const expected = 25 * Math.PI * 80;
+            expect(vol).toBeGreaterThan(expected * 0.98);
+            expect(vol).toBeLessThan(expected * 1.02);
+        });
+        it("is a no-op for a non-positive amount", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile).extend("end", 0);
+            render();
+            const bbox = ShapeOps.getBoundingBox(s.getShapes()[0]);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(50, 0);
+        });
+        it("throws on an invalid side", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            expect(() => sweep(path, profile).extend("middle", 10)).toThrow();
+        });
+    });
 });

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

@@ -20,8 +20,10 @@ function solidsOf(e) {
 }
 describe("text", () => {
     setupOC();
-    it("extrudes standalone text on a plane into a solid", () => {
-        text("xy", "A").size(20);
+    it("extrudes text on a plane into a solid", () => {
+        sketch("xy", () => {
+            text("A").size(20);
+        });
         const e = extrude(5);
         render();
         const solids = solidsOf(e);
@@ -53,19 +55,25 @@ describe("text", () => {
     it("builds a letter with a counter (hole) such as 'o'", () => {
         // Outer + inner contours must both build; FaceMaker2 drills the counter.
         // We don't assert exact topology (font-dependent) — only a valid solid.
-        text("xy", "o").size(20);
+        sketch("xy", () => {
+            text("o").size(20);
+        });
         const e = extrude(4);
         render();
         expect(solidsOf(e).length).toBeGreaterThanOrEqual(1);
     });
     it("falls back to a default font when the named font is missing", () => {
-        text("xy", "Z").size(20).font("NoSuchFont__XYZ");
+        sketch("xy", () => {
+            text("Z").size(20).font("NoSuchFont__XYZ");
+        });
         const e = extrude(4);
         render();
         expect(solidsOf(e).length).toBeGreaterThanOrEqual(1);
     });
     it("honours font weight without throwing", () => {
-        text("xy", "B").size(20).weight("bold");
+        sketch("xy", () => {
+            text("B").size(20).weight("bold");
+        });
         const e = extrude(4);
         render();
         expect(solidsOf(e).length).toBeGreaterThanOrEqual(1);
@@ -88,7 +96,9 @@ describe("text", () => {
         const root = process.env.FLUIDCAD_WORKSPACE_PATH;
         fs.mkdirSync(join(root, "fonts"), { recursive: true });
         fs.copyFileSync(src, join(root, "fonts", "test.ttf"));
-        text("xy", "A").size(20).font("fonts/test.ttf");
+        sketch("xy", () => {
+            text("A").size(20).font("fonts/test.ttf");
+        });
         const e = extrude(5);
         render();
         expect(solidsOf(e).length).toBeGreaterThanOrEqual(1);
@@ -187,9 +197,9 @@ describe("text along a path", () => {
         expect(bbox.maxX).toBeLessThan(101);
         expect(bbox.maxX).toBeGreaterThan(85);
     });
-    it("follows a standalone planar primitive and wraps on a closed path", () => {
+    it("follows a closed circular path and wraps around", () => {
         // Text much longer than the circumference must wrap, not error.
-        const ring = circle("xy", 30); // radius 15, circumference ~94
+        const ring = sketch("xy", () => circle(30)); // radius 15, circumference ~94
         const t = text("WRAPPING ALL THE WAY AROUND", ring).size(8);
         render();
         expect(t.getError()).toBeFalsy();
@@ -232,12 +242,15 @@ describe("text along a path", () => {
         expect(t.getError()).toMatch(/planar/i);
     });
     it("rejects path-only modifiers without a path", () => {
-        const t = text("xy", "Hi").offset(3);
+        let t;
+        sketch("xy", () => {
+            t = text("Hi").offset(3);
+        });
         render();
         expect(t.getError()).toMatch(/offset/i);
     });
     it("sits on the outside of a closed circle by default", () => {
-        const ring = circle("xy", 100); // radius 50
+        const ring = sketch("xy", () => circle(100)); // radius 50
         const t = text("OUTSIDE", ring).size(8);
         render();
         expect(t.getError()).toBeFalsy();
@@ -249,7 +262,7 @@ describe("text along a path", () => {
         expect(mean).toBeGreaterThan(50);
     });
     it("moves closed-path text inside with flip", () => {
-        const ring = circle("xy", 100); // radius 50
+        const ring = sketch("xy", () => circle(100)); // radius 50
         const t = text("INSIDE", ring).size(8).flip();
         render();
         expect(t.getError()).toBeFalsy();
@@ -297,12 +310,18 @@ describe("text along a path", () => {
         expect(bbox.maxX).toBeGreaterThan(85);
     });
     it("rejects space-between alignment without a path", () => {
-        const t = text("xy", "Hi").align("space-between");
+        let t;
+        sketch("xy", () => {
+            t = text("Hi").align("space-between");
+        });
         render();
         expect(t.getError()).toMatch(/space-between/i);
     });
     it("rejects space-around alignment without a path", () => {
-        const t = text("xy", "Hi").align("space-around");
+        let t;
+        sketch("xy", () => {
+            t = text("Hi").align("space-around");
+        });
         render();
         expect(t.getError()).toMatch(/space-around/i);
     });
@@ -337,7 +356,7 @@ describe("text along a path", () => {
         expect(bbox.maxZ - bbox.minZ).toBeCloseTo(4, 0);
     });
     it("multiple texts can share one path", () => {
-        const ring = circle("xy", 100);
+        const ring = sketch("xy", () => circle(100));
         const outside = text("OUTSIDE", ring).size(8);
         const inside = text("INSIDE", ring).size(8).flip();
         render();

package/lib/dist/tests/math/bspline-interpolation.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { interpolateBSpline2d } from "../../math/bspline-interpolation.js";
+import { interpolateBSpline2d, interpolateWithDerivatives, } from "../../math/bspline-interpolation.js";
 /** Evaluates the B-spline at t via Cox–de Boor (independent of OCC). */
 function evaluate(data, t) {
     const flat = [];
@@ -117,3 +117,99 @@ describe("interpolateBSpline2d", () => {
         expect(data.poles.length).toBe(4);
     });
 });
+/** Evaluates an N-dimensional B-spline at t via Cox–de Boor. */
+function evaluateNd(data, t) {
+    const flat = [];
+    for (let i = 0; i < data.knots.length; i++) {
+        for (let m = 0; m < data.multiplicities[i]; m++) {
+            flat.push(data.knots[i]);
+        }
+    }
+    const asXY = {
+        poles: data.poles.map(p => ({ x: p[0], y: p.length > 1 ? p[1] : 0 })),
+        knots: data.knots,
+        multiplicities: data.multiplicities,
+        degree: data.degree,
+    };
+    // Reuse the 2D evaluator per dimension pair to keep this helper simple.
+    const result = [];
+    const dimension = data.poles[0].length;
+    for (let d = 0; d < dimension; d += 2) {
+        const pair = {
+            ...asXY,
+            poles: data.poles.map(p => ({ x: p[d], y: d + 1 < dimension ? p[d + 1] : 0 })),
+        };
+        const q = evaluate(pair, t);
+        result.push(q.x);
+        if (d + 1 < dimension) {
+            result.push(q.y);
+        }
+    }
+    return result;
+}
+/** Central-difference derivative of the curve at t. */
+function numericDerivative(data, t) {
+    const h = 1e-7;
+    const t0 = Math.max(data.knots[0], t - h);
+    const t1 = Math.min(data.knots[data.knots.length - 1], t + h);
+    const a = evaluateNd(data, t0);
+    const b = evaluateNd(data, t1);
+    return a.map((v, d) => (b[d] - v) / (t1 - t0));
+}
+describe("interpolateWithDerivatives", () => {
+    const points = [
+        [0, 0, 0],
+        [1, 2, 1],
+        [3, 1, 2],
+        [4, 4, 3],
+    ];
+    const params = [0, 0.3, 0.7, 1];
+    it("passes through every point with both end derivatives constrained", () => {
+        const data = interpolateWithDerivatives(points, params, [0, 0, 5], [5, 0, 0]);
+        expect(data.degree).toBe(3);
+        expect(data.poles.length).toBe(points.length + 2);
+        for (let k = 0; k < points.length; k++) {
+            const q = evaluateNd(data, params[k]);
+            for (let d = 0; d < 3; d++) {
+                expect(q[d]).toBeCloseTo(points[k][d], 9);
+            }
+        }
+    });
+    it("matches the requested end derivatives", () => {
+        const startD = [0, 0, 5];
+        const endD = [5, 0, 0];
+        const data = interpolateWithDerivatives(points, params, startD, endD);
+        const atStart = numericDerivative(data, 0);
+        const atEnd = numericDerivative(data, 1);
+        for (let d = 0; d < 3; d++) {
+            expect(atStart[d]).toBeCloseTo(startD[d], 4);
+            expect(atEnd[d]).toBeCloseTo(endD[d], 4);
+        }
+    });
+    it("supports a single constrained end", () => {
+        const startD = [0, 0, 4];
+        const data = interpolateWithDerivatives(points, params, startD, undefined);
+        expect(data.poles.length).toBe(points.length + 1);
+        for (let k = 0; k < points.length; k++) {
+            const q = evaluateNd(data, params[k]);
+            for (let d = 0; d < 3; d++) {
+                expect(q[d]).toBeCloseTo(points[k][d], 9);
+            }
+        }
+        const atStart = numericDerivative(data, 0);
+        for (let d = 0; d < 3; d++) {
+            expect(atStart[d]).toBeCloseTo(startD[d], 4);
+        }
+    });
+    it("reproduces a cubic Hermite segment for two points with derivatives", () => {
+        const data = interpolateWithDerivatives([[0, 0, 0], [1, 0, 0]], [0, 1], [0, 1, 0], [0, -1, 0]);
+        expect(data.degree).toBe(3);
+        expect(data.poles.length).toBe(4);
+        // Bézier form of the Hermite segment: P1 = P0 + D0/3, P2 = P3 - D1/3.
+        expect(data.poles[1][1]).toBeCloseTo(1 / 3, 9);
+        expect(data.poles[2][1]).toBeCloseTo(1 / 3, 9);
+    });
+    it("rejects non-increasing parameters", () => {
+        expect(() => interpolateWithDerivatives([[0, 0], [1, 1], [2, 2]], [0, 0.5, 0.5])).toThrow(/strictly increasing/);
+    });
+});