fluidcad 0.0.30 → 0.0.32

package/lib/dist/tests/features/cylinder-curve-filter.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import fillet from "../../core/fillet.js";
+import select from "../../core/select.js";
+import { rect } from "../../core/2d/index.js";
+import { face, edge } from "../../filters/index.js";
+import cylinder from "../../core/cylinder.js";
+import { getFacesByType } from "../utils.js";
+import { FaceQuery } from "../../oc/face-query.js";
+import { Explorer } from "../../oc/explorer.js";
+import { getOC } from "../../oc/init.js";
+function getSolid() {
+    return render().getAllSceneObjects()
+        .flatMap(o => o.getShapes())
+        .find(s => s.getType() === "solid");
+}
+describe("cylinderCurve filter on fillet faces", () => {
+    setupOC();
+    it("recognizes fillet faces produced from straight vertical edges (no draft)", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        extrude(30);
+        select(edge().verticalTo("xy"));
+        fillet(5);
+        const solid = getSolid();
+        const cylFaces = getFacesByType(solid, "cylinder");
+        expect(cylFaces).toHaveLength(4);
+        const cylinderCurveFaces = cylFaces.filter(f => FaceQuery.isCylinderCurveFace(f));
+        expect(cylinderCurveFaces).toHaveLength(4);
+    });
+    it("recognizes fillet faces produced from drafted vertical edges (matches user repro)", () => {
+        sketch("xy", () => {
+            rect(205, 133).centered();
+        });
+        const body = extrude(100).draft(10);
+        fillet(32, body.sideEdges());
+        const solid = getSolid();
+        const cylFaces = getFacesByType(solid, "cylinder");
+        expect(cylFaces.length).toBeGreaterThan(0);
+        const cylinderCurveFaces = cylFaces.filter(f => FaceQuery.isCylinderCurveFace(f));
+        if (cylinderCurveFaces.length !== cylFaces.length) {
+            const oc = getOC();
+            const missed = cylFaces.filter(f => !FaceQuery.isCylinderCurveFace(f));
+            for (const face of missed) {
+                const ocFace = oc.TopoDS.Face(face.getShape());
+                const edges = Explorer.findShapes(ocFace, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+                const curveTypeNames = {};
+                for (const k of Object.keys(oc.GeomAbs_CurveType)) {
+                    const v = oc.GeomAbs_CurveType[k];
+                    if (v && typeof v.value === "number") {
+                        curveTypeNames[v.value] = k;
+                    }
+                }
+                const edgeInfo = edges.map(e => {
+                    const adaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(e));
+                    const t = adaptor.GetType();
+                    const closed = adaptor.IsClosed();
+                    adaptor.delete();
+                    return { type: curveTypeNames[t.value] ?? t.value, closed };
+                });
+                console.log("Cylinder face missed by cylinderCurve:", JSON.stringify(edgeInfo));
+            }
+        }
+        expect(cylinderCurveFaces).toHaveLength(cylFaces.length);
+    });
+    it("face().cylinderCurve() returns fillet faces (drafted body)", () => {
+        sketch("xy", () => {
+            rect(205, 133).centered();
+        });
+        const body = extrude(100).draft(10);
+        fillet(32, body.sideEdges());
+        const sel = select(face().cylinderCurve());
+        render();
+        const selectedFaces = sel.getShapes();
+        expect(selectedFaces.length).toBeGreaterThan(0);
+    });
+    it("cylinderCurve(diameter) matches the cylinder surface radius, not bounding-edge radius", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        extrude(30);
+        select(edge().verticalTo("xy"));
+        fillet(5);
+        const matchingSel = select(face().cylinderCurve(10));
+        const nonMatchingSel = select(face().cylinderCurve(20));
+        render();
+        expect(matchingSel.getShapes()).toHaveLength(4);
+        expect(nonMatchingSel.getShapes()).toHaveLength(0);
+    });
+    it("cylinderCurve does NOT match a full cylinder primitive", () => {
+        cylinder(20, 30);
+        const sel = select(face().cylinderCurve());
+        render();
+        expect(sel.getShapes()).toHaveLength(0);
+    });
+});

package/lib/dist/tests/features/extrude-to-face.test.js

@@ -121,6 +121,58 @@ describe("extrude to face", () => {
             expect(lastBBox.maxZ).toBeGreaterThan(firstBBox.maxZ);
         });
     });
+    describe("first-face / last-face with filters", () => {
+        it("should narrow the candidate set with a face filter", () => {
+            // Cylinder at origin and a planar slab nearby. Without a filter,
+            // 'first-face' would pick the slab's top (at z=20). The cylinder
+            // filter forces selection of the cylindrical side face (z=40).
+            cylinder(50, 80);
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(50, 50);
+            });
+            extrude(20).new();
+            sketch("xy", () => {
+                move([200, 100]);
+                rect(30, 30);
+            });
+            const e = extrude("first-face", face().cylinder());
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should record an error when the filter eliminates all candidate faces", () => {
+            // Scene contains only planar geometry — cylinder filter matches nothing
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(50, 50);
+            });
+            extrude(30).new();
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude("first-face", face().cylinder());
+            render();
+            expect(e.getError()).toMatch(/No face found for 'first-face' extrusion/);
+        });
+        it("should accept a filter together with an explicit target", () => {
+            cylinder(50, 80);
+            const target = sketch("xy", () => {
+                move([200, 100]);
+                rect(20, 20);
+            });
+            // Some other sketch in scope so the sketch context is non-trivial.
+            sketch("xy", () => {
+                rect(10, 10);
+            });
+            const e = extrude("first-face", face().cylinder(), target);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
     describe("non-parallel planar face", () => {
         it("should extrude up to a drafted side face", () => {
             // Create a box with drafted sides — side faces are inclined planes

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

@@ -84,6 +84,27 @@ describe("extrude", () => {
             const scene = render();
             expect(countShapes(scene)).toBe(2);
         });
+        it("should only fuse with scene objects the new extrusion actually touches", () => {
+            // C1: cylinder at origin, z = 0..50
+            sketch("top", () => {
+                circle(50);
+            });
+            const e = extrude(50);
+            // C2: cylinder stacked on C1, z = 50..100, kept as a separate scene object
+            sketch(e.endFaces(), () => {
+                circle(50);
+            });
+            extrude(50).new();
+            // C3: cylinder at [100, 0] radius 50, externally tangent to C1, doesn't touch C2 at all
+            sketch("top", () => {
+                circle([100, 0], 50);
+            });
+            extrude();
+            const scene = render();
+            // C1 and C2 must remain separate solids — the third extrude should not
+            // pull them into a fusion with each other.
+            expect(countShapes(scene)).toBe(3);
+        });
     });
     describe("startFaces / endFaces", () => {
         it("should expose start face", () => {
@@ -259,6 +280,25 @@ describe("extrude", () => {
             expect(bbox.minZ).toBeCloseTo(0, 0);
             expect(bbox.maxZ).toBeCloseTo(30, 0);
         });
+        it("reverse-direction extrude classifies side/internal faces correctly", () => {
+            sketch("xy", () => {
+                rect(7, 5).centered();
+            });
+            const e = extrude(-1.5);
+            const sf = e.sideFaces();
+            const inf = e.internalFaces();
+            const se = e.sideEdges();
+            const ine = e.internalEdges();
+            addToScene(sf);
+            addToScene(inf);
+            addToScene(se);
+            addToScene(ine);
+            render();
+            expect(sf.getShapes()).toHaveLength(4);
+            expect(inf.getShapes()).toHaveLength(0);
+            expect(se.getShapes()).toHaveLength(4);
+            expect(ine.getShapes()).toHaveLength(0);
+        });
     });
     describe("startEdges / endEdges", () => {
         it("should expose start edges", () => {
@@ -446,17 +486,15 @@ describe("extrude", () => {
         it("should not include guide shapes in getShapes()", () => {
             sketch("xy", () => {
                 rect(100, 50);
+                circle([50, 25], 20).guide();
             });
-            const e = extrude(30).guide();
+            const e = extrude(30);
             render();
+            // The guide circle is excluded from the extrusion — the result is a
+            // plain box (6 faces), not a box with a circular hole (8 faces).
             const shapes = e.getShapes();
-            expect(shapes).toHaveLength(0);
-            // All added shapes should be marked as guide
-            const allShapes = e.getAddedShapes();
-            expect(allShapes.length).toBeGreaterThan(0);
-            for (const shape of allShapes) {
-                expect(shape.isGuideShape()).toBe(true);
-            }
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getFaces()).toHaveLength(6);
         });
         it("should include meta shapes when filter is disabled", () => {
             sketch("xy", () => {

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

@@ -109,6 +109,80 @@ describe("mirror (3D)", () => {
             expect(countShapes(scene)).toBe(1);
         });
     });
+    describe("mirror with .new()", () => {
+        it("should not fuse the mirrored copy with overlapping objects", () => {
+            // Centered cube — mirror across YZ produces a copy that overlaps the original.
+            // Default .add() would fuse to a single solid; .new() must keep them separate.
+            sketch("xy", () => {
+                rect(30, 30);
+            });
+            extrude(20).new();
+            mirror("yz").new();
+            const scene = render();
+            expect(countShapes(scene)).toBe(2);
+        });
+    });
+    describe("mirror with .remove()", () => {
+        it("should cut the mirrored copy out of the scene", () => {
+            // Solid spans y=-5..25 — mirroring across XZ overlaps in the y=-5..5 strip.
+            // .remove() uses the mirrored copy as a cut tool, leaving y=5..25.
+            sketch("xy", () => {
+                move([0, -5]);
+                rect(30, 30);
+            });
+            extrude(20).new();
+            mirror("xz").remove();
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.minY).toBeCloseTo(5, 0);
+            expect(bbox.maxY).toBeCloseTo(25, 0);
+        });
+    });
+    describe("mirror with .scope()", () => {
+        it("should narrow .add() fusion to scoped objects only", () => {
+            // e1 is centered (mirror would overlap it); e2 is far away.
+            sketch("xy", () => {
+                rect(30, 30);
+            });
+            const e1 = extrude(20).new();
+            sketch("xy", () => {
+                move([60, 0]);
+                rect(30, 30);
+            });
+            const e2 = extrude(20).new();
+            // Mirror only e1 across YZ, but scope fusion to e2 (which doesn't intersect).
+            // The mirrored copy of e1 stays standalone; e1 and e2 are untouched.
+            mirror("yz", e1).add().scope(e2);
+            const scene = render();
+            // e1 + e2 + standalone mirrored-e1 = 3
+            expect(countShapes(scene)).toBe(3);
+        });
+        it("should narrow .remove() cut to scoped objects only", () => {
+            // Both solids cross the XZ plane — mirror across XZ would cut both by default.
+            sketch("xy", () => {
+                move([0, -5]);
+                rect(30, 30);
+            });
+            const e1 = extrude(20).new();
+            sketch("xy", () => {
+                move([60, -5]);
+                rect(30, 30);
+            });
+            const e2 = extrude(20).new();
+            // Cut only e1, leave e2 untouched.
+            mirror("xz", e1).remove().scope(e1);
+            const scene = render();
+            expect(countShapes(scene)).toBe(2);
+            const e2Shapes = e2.getShapes();
+            const e2Bbox = ShapeOps.getBoundingBox(e2Shapes[0]);
+            expect(e2Bbox.minY).toBeCloseTo(-5, 0);
+            expect(e2Bbox.maxY).toBeCloseTo(25, 0);
+        });
+    });
     describe("mirror with .exclude()", () => {
         it("should skip excluded objects when mirroring everything", () => {
             sketch("xy", () => {

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

@@ -7,6 +7,7 @@ import cylinder from "../../core/cylinder.js";
 import fillet from "../../core/fillet.js";
 import { circle, move, rect } from "../../core/2d/index.js";
 import { face, edge } from "../../filters/index.js";
+import part from "../../core/part.js";
 describe("select", () => {
     setupOC();
     describe("face filters", () => {
@@ -227,6 +228,30 @@ describe("select", () => {
                 expect(sel.getShapes()).toHaveLength(3);
             });
         });
+        describe("planar / notPlanar", () => {
+            it("should select planar faces from a drafted extrusion", () => {
+                sketch("xy", () => {
+                    circle(60);
+                });
+                extrude(50).draft(10);
+                const sel = select(face().planar());
+                render();
+                // Drafted cylinder: top + bottom flat circles are planar (1 cone side is not)
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(2);
+            });
+            it("should exclude planar faces", () => {
+                sketch("xy", () => {
+                    circle(60);
+                });
+                extrude(50).draft(10);
+                const sel = select(face().notPlanar());
+                render();
+                // Only the conical side face is non-planar
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(1);
+            });
+        });
         describe("cone / notCone", () => {
             it("should select conical faces from a drafted extrusion", () => {
                 sketch("xy", () => {
@@ -251,6 +276,72 @@ describe("select", () => {
                 expect(shapes).toHaveLength(2);
             });
         });
+        describe("above / below", () => {
+            it("should select faces entirely above a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Faces above z=15: only the top face (all verts at z=30) qualifies.
+                // Side faces have 2 verts at z=0 (not above), so they don't match.
+                const sel = select(face().above("xy", { offset: 15 }));
+                render();
+                expect(sel.getShapes()).toHaveLength(1);
+            });
+            it("should select faces entirely below a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Faces below z=15: only the bottom face (all verts at z=0) qualifies.
+                const sel = select(face().below("xy", { offset: 15 }));
+                render();
+                expect(sel.getShapes()).toHaveLength(1);
+            });
+            it("should not match faces on the plane itself", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Faces above z=0: bottom face is ON the plane (dist=0), not above.
+                // Side faces straddle (2 verts on plane). Only top face qualifies.
+                const sel = select(face().above("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(1);
+            });
+            it("should select partially above faces", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true — match faces with at least one vertex above z=0.
+                // Top face + 4 side faces (each has 2 verts at z=30) = 5.
+                const sel = select(face().above("xy", { partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(5);
+            });
+            it("should select partially below faces", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true — match faces with at least one vertex below z=30.
+                // Bottom face + 4 side faces (each has 2 verts at z=0) = 5.
+                const sel = select(face().below("xy", { offset: 30, partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(5);
+            });
+            it("should return empty when no faces match", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Nothing is below z=0 on a box sitting on XY.
+                const sel = select(face().below("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(0);
+            });
+        });
     });
     describe("edge filters", () => {
         describe("onPlane / notOnPlane", () => {
@@ -834,4 +925,54 @@ describe("select", () => {
             });
         });
     });
+    describe("cross-part selection", () => {
+        it("should select faces from another part via from()", () => {
+            const p1 = part("p1", () => {
+                cylinder(50, 100);
+            });
+            let sel;
+            part("p2", () => {
+                sel = select(face().from(p1));
+            });
+            render();
+            // A cylinder has 3 faces (top, bottom, lateral)
+            expect(sel.getShapes()).toHaveLength(3);
+        });
+        it("should narrow cross-part selection by additional filters", () => {
+            const p1 = part("p1", () => {
+                cylinder(50, 100);
+            });
+            let sel;
+            part("p2", () => {
+                sel = select(face().cylinder().from(p1));
+            });
+            render();
+            // Only the lateral cylindrical face
+            expect(sel.getShapes()).toHaveLength(1);
+        });
+        it("should select edges from another part via edge().from()", () => {
+            const p1 = part("p1", () => {
+                cylinder(50, 100);
+            });
+            let sel;
+            part("p2", () => {
+                sel = select(edge().from(p1));
+            });
+            render();
+            // A cylinder has 3 edges (top circle, bottom circle, seam)
+            expect(sel.getShapes()).toHaveLength(3);
+        });
+        it("should narrow cross-part edge selection by additional filters", () => {
+            const p1 = part("p1", () => {
+                cylinder(50, 100);
+            });
+            let sel;
+            part("p2", () => {
+                sel = select(edge().circle().from(p1));
+            });
+            render();
+            // The two circular edges (top + bottom) — seam is excluded
+            expect(sel.getShapes()).toHaveLength(2);
+        });
+    });
 });

package/lib/dist/tests/features/subtract-consumed-input.test.d.ts

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

package/lib/dist/tests/features/subtract-consumed-input.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import revolve from "../../core/revolve.js";
+import subtract from "../../core/subtract.js";
+import axis from "../../core/axis.js";
+import translate from "../../core/translate.js";
+import { circle } from "../../core/2d/index.js";
+describe("subtract: consumed-input diagnostic (issue #50)", () => {
+    setupOC();
+    it("explains which earlier op consumed an empty operand", () => {
+        const torusAxis = axis('y', { offsetZ: 20 });
+        sketch('yz', () => {
+            circle(8);
+        });
+        const torus1 = revolve(torusAxis).name(' torus1');
+        translate([0, 5, 0], torus1);
+        sketch('yz', () => {
+            circle(8);
+        });
+        const torus2 = revolve(torusAxis).new().name(' torus2');
+        const sub = subtract(torus1, torus2);
+        render();
+        const err = sub.getError();
+        expect(err).toMatch(/subtract:.*first operand.*has no shapes.*translate/);
+        expect(err).toMatch(/Hint:/);
+    });
+});

package/lib/dist/tests/features/thin-extrude-offset-fix.test.d.ts

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

package/lib/dist/tests/features/thin-extrude-offset-fix.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import select from "../../core/select.js";
+import fillet from "../../core/fillet.js";
+import { rect, intersect, offset } from "../../core/2d/index.js";
+import { edge } from "../../filters/index.js";
+describe("thin extrude offset auto-fix", () => {
+    setupOC();
+    it("falls back to face-spine offset when wire-spine offset fails", () => {
+        // The drafted body's filleted corners produce GeomAbs_OffsetCurve edges
+        // when sectioned at z=0 and offset by -6. BRepOffsetAPI_MakeOffset's
+        // wire-spine path can't re-offset that wire (it throws "Offset wire is
+        // not closed."), but the face-spine path can — ThinFaceMaker.doOffset
+        // should retry on failure.
+        sketch("top", () => {
+            rect(205, 133).centered();
+        });
+        const body = extrude(100).draft(10);
+        fillet(32, body.sideEdges());
+        const s = select(edge().onPlane("top"));
+        sketch("bottom", () => {
+            intersect(s);
+            offset(-6, true);
+        });
+        const thin = extrude(5).thin(1.25, 1.25);
+        render();
+        expect(thin.getError()).toBeNull();
+        const shapes = thin.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+        expect(shapes[0].getType()).toBe('solid');
+    });
+});