fluidcad 0.0.38 → 0.0.39

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

@@ -478,4 +478,85 @@ describe("sweep", () => {
             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/);
+    });
+});