fluidcad 0.0.6 → 0.0.8

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

@@ -296,6 +296,99 @@ describe("select", () => {
             expect(sel.getShapes()).toHaveLength(4);
         });
     });
+    describe("hasEdge / notHasEdge", () => {
+        it("should select faces that have circular edges", () => {
+            cylinder(30, 50);
+            // All 3 faces have circular edges (top, bottom, and cylindrical side bounded by circles)
+            const sel = select(face().hasEdge(edge().circle()));
+            render();
+            expect(sel.getShapes()).toHaveLength(3);
+        });
+        it("should select faces that have line edges", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // All 6 faces of a box have line edges
+            const sel = select(face().hasEdge(edge().line()));
+            render();
+            expect(sel.getShapes()).toHaveLength(6);
+        });
+        it("should select faces with multiple edge criteria (AND)", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Faces that have both a line edge on XY AND a line edge on XY offset 30
+            // The 4 side faces each have edges on both bottom and top planes
+            const sel = select(face().hasEdge(edge().onPlane("xy"), edge().onPlane("xy", 30)));
+            render();
+            expect(sel.getShapes()).toHaveLength(4);
+        });
+        it("should select faces with vertical and horizontal edges", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Side faces have both vertical and horizontal edges
+            const sel = select(face().hasEdge(edge().verticalTo("xy"), edge().parallelTo("xy")));
+            render();
+            // 4 side faces
+            expect(sel.getShapes()).toHaveLength(4);
+        });
+        it("should combine hasEdge with other face filters", () => {
+            cylinder(30, 50);
+            // Circle faces that also have circular edges
+            const sel = select(face().circle().hasEdge(edge().circle()));
+            render();
+            expect(sel.getShapes()).toHaveLength(2);
+        });
+        it("should exclude faces with notHasEdge", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Exclude faces that have vertical edges → only top and bottom faces remain
+            const sel = select(face().notHasEdge(edge().verticalTo("xy")));
+            render();
+            expect(sel.getShapes()).toHaveLength(2);
+        });
+        it("should have complementary results between hasEdge and notHasEdge", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Side faces have vertical edges, top/bottom do not
+            const has = select(face().hasEdge(edge().verticalTo("xy")));
+            const notHas = select(face().notHasEdge(edge().verticalTo("xy")));
+            render();
+            expect(has.getShapes()).toHaveLength(4);
+            expect(notHas.getShapes()).toHaveLength(2);
+            // No overlap
+            for (const s of has.getShapes()) {
+                expect(notHas.getShapes().some(ns => ns.isSame(s))).toBe(false);
+            }
+        });
+        it("should select faces matching edges from a scene object", () => {
+            cylinder(30, 50);
+            const circleEdges = select(edge().circle());
+            const sel = select(face().hasEdge(circleEdges));
+            render();
+            // All 3 cylinder faces share a circular edge
+            expect(sel.getShapes()).toHaveLength(3);
+        });
+        it("should exclude faces with notHasEdge using a scene object", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            const bottomEdges = select(edge().belongsToFace(face().onPlane("xy")));
+            const sel = select(face().notHasEdge(bottomEdges));
+            render();
+            // Top face has no edges from the bottom face selection
+            expect(sel.getShapes()).toHaveLength(1);
+        });
+    });
     describe("OR logic (multiple builders)", () => {
         it("should match faces satisfying any builder", () => {
             cylinder(30, 50);
@@ -334,4 +427,160 @@ describe("select", () => {
             expect(sel.getShapes()).toHaveLength(5);
         });
     });
+    describe("belongsToFace / notBelongsToFace", () => {
+        it("should select edges belonging to circular faces", () => {
+            cylinder(30, 50);
+            // Circular faces (top and bottom discs) each have 1 circular edge
+            const sel = select(edge().belongsToFace(face().circle()));
+            render();
+            expect(sel.getShapes()).toHaveLength(2);
+            expect(sel.getShapes().every(s => s.getType() === "edge")).toBe(true);
+        });
+        it("should select edges belonging to faces on a specific plane", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Bottom face (on XY) has 4 edges
+            const sel = select(edge().belongsToFace(face().onPlane("xy")));
+            render();
+            expect(sel.getShapes()).toHaveLength(4);
+        });
+        it("should select edges belonging to faces on offset plane", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Top face (on XY offset 30) has 4 edges
+            const sel = select(edge().belongsToFace(face().onPlane("xy", 30)));
+            render();
+            expect(sel.getShapes()).toHaveLength(4);
+        });
+        it("should select edges with multiple face criteria (AND)", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Edges belonging to a face that is both parallel to XY AND on the bottom plane
+            // Only the bottom face matches both criteria → 4 edges
+            const sel = select(edge().belongsToFace(face().parallelTo("xy").onPlane("xy")));
+            render();
+            expect(sel.getShapes()).toHaveLength(4);
+        });
+        it("should select edges with multiple face filter builders (AND across builders)", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Edges that belong to a face on XY AND also belong to a face NOT parallel to XY
+            // Bottom face edges: the 4 bottom edges each also belong to a side face (not parallel to XY)
+            const sel = select(edge().belongsToFace(face().onPlane("xy"), face().notParallelTo("xy")));
+            render();
+            // All 4 bottom edges belong to the bottom face (on XY) AND each belongs to a side face (not parallel to XY)
+            expect(sel.getShapes()).toHaveLength(4);
+        });
+        it("should combine belongsToFace with other edge filters", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Line edges that belong to faces parallel to XY (top and bottom)
+            // Top face has 4 edges, bottom face has 4 edges → 8 edges total
+            const sel = select(edge().line().belongsToFace(face().parallelTo("xy")));
+            render();
+            expect(sel.getShapes()).toHaveLength(8);
+        });
+        it("should combine belongsToFace with circle edge filter", () => {
+            cylinder(30, 50);
+            // Circular edges that belong to circular faces (discs)
+            // Top and bottom discs each have 1 circular edge → 2 edges
+            const sel = select(edge().circle().belongsToFace(face().circle()));
+            render();
+            expect(sel.getShapes()).toHaveLength(2);
+        });
+        it("should select edges belonging to cylindrical faces", () => {
+            cylinder(30, 50);
+            // The cylindrical side face has 3 edges: 2 circular (top/bottom) + 1 seam edge
+            const sel = select(edge().belongsToFace(face().cylinder()));
+            render();
+            expect(sel.getShapes()).toHaveLength(3);
+        });
+        it("should exclude edges with notBelongsToFace", () => {
+            cylinder(30, 50);
+            // Exclude edges belonging to circular faces → only edges on the cylindrical face that aren't shared with discs
+            // Cylinder has 3 total edges: 2 circles + 1 seam. The 2 circles belong to circular faces.
+            // The seam edge only belongs to the cylindrical face.
+            const sel = select(edge().notBelongsToFace(face().circle()));
+            render();
+            // Only the seam edge doesn't belong to any circular face
+            expect(sel.getShapes()).toHaveLength(1);
+        });
+        it("should have complementary results between belongsToFace and notBelongsToFace", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Edges belonging to the bottom face vs edges NOT belonging to the bottom face
+            const belongs = select(edge().belongsToFace(face().onPlane("xy")));
+            const notBelongs = select(edge().notBelongsToFace(face().onPlane("xy")));
+            render();
+            expect(belongs.getShapes()).toHaveLength(4);
+            // Box has 12 edges total, 4 on bottom face → 8 not on bottom
+            expect(notBelongs.getShapes()).toHaveLength(8);
+            // No overlap
+            for (const s of belongs.getShapes()) {
+                expect(notBelongs.getShapes().some(ns => ns.isSame(s))).toBe(false);
+            }
+        });
+        it("should cover all edges between belongsToFace and notBelongsToFace", () => {
+            cylinder(30, 50);
+            const belongs = select(edge().belongsToFace(face().cylinder()));
+            const notBelongs = select(edge().notBelongsToFace(face().cylinder()));
+            render();
+            // Cylinder has 3 edges total, all belong to the cylindrical face
+            expect(belongs.getShapes().length + notBelongs.getShapes().length).toBe(3);
+            // No overlap
+            for (const s of belongs.getShapes()) {
+                expect(notBelongs.getShapes().some(ns => ns.isSame(s))).toBe(false);
+            }
+        });
+        it("should select all edges when face filter matches all faces", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Every edge belongs to at least one face that has line edges (all 6 faces of a box)
+            const sel = select(edge().belongsToFace(face().hasEdge(edge().line())));
+            render();
+            // All 12 edges of the box
+            expect(sel.getShapes()).toHaveLength(12);
+        });
+        it("should use OR logic with multiple builders", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Edges on bottom face OR edges on top face
+            const sel = select(edge().belongsToFace(face().onPlane("xy")), edge().belongsToFace(face().onPlane("xy", 30)));
+            render();
+            // 4 bottom + 4 top = 8 edges
+            expect(sel.getShapes()).toHaveLength(8);
+        });
+        it("should select edges belonging to faces from a scene object", () => {
+            cylinder(30, 50);
+            const circleFaces = select(face().circle());
+            const sel = select(edge().belongsToFace(circleFaces));
+            render();
+            // Top and bottom disc faces each have 1 circular edge = 2 edges
+            expect(sel.getShapes()).toHaveLength(2);
+        });
+        it("should exclude edges with notBelongsToFace using a scene object", () => {
+            cylinder(30, 50);
+            const circleFaces = select(face().circle());
+            const sel = select(edge().notBelongsToFace(circleFaces));
+            render();
+            // Cylinder has 3 edges; 2 belong to circle faces, so 1 remains (the seam)
+            expect(sel.getShapes()).toHaveLength(1);
+        });
+    });
 });

package/lib/dist/tests/features/subtract2d.test.d.ts

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

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

@@ -0,0 +1,63 @@
+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 subtract from "../../core/subtract.js";
+import { circle, rect } from "../../core/2d/index.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+describe("subtract2d", () => {
+    setupOC();
+    it("should subtract one circle from another", () => {
+        sketch("xy", () => {
+            const c1 = circle(60);
+            const c2 = circle([30, 0], 40);
+            subtract(c1, c2);
+        });
+        const e = extrude(20);
+        render();
+        const shapes = e.getShapes();
+        expect(shapes).toHaveLength(1);
+        expect(shapes[0].getType()).toBe("solid");
+        // Result should be narrower than the base circle
+        const bbox = ShapeOps.getBoundingBox(shapes[0]);
+        const width = bbox.maxX - bbox.minX;
+        expect(width).toBeLessThan(120);
+    });
+    it("should subtract a rect from a circle", () => {
+        sketch("xy", () => {
+            const c1 = circle(60);
+            const r1 = rect([0, 0], 40, 40);
+            subtract(c1, r1);
+        });
+        const e = extrude(20);
+        render();
+        const shapes = e.getShapes();
+        expect(shapes).toHaveLength(1);
+        expect(shapes[0].getType()).toBe("solid");
+    });
+    it("should remove original edges from both operands", () => {
+        const s = sketch("xy", () => {
+            const c1 = circle(60);
+            const c2 = circle([30, 0], 40);
+            subtract(c1, c2);
+        });
+        render();
+        // Original circles should have their edges removed
+        const c1Shapes = s.getChildren()[0].getShapes();
+        const c2Shapes = s.getChildren()[1].getShapes();
+        expect(c1Shapes).toHaveLength(0);
+        expect(c2Shapes).toHaveLength(0);
+    });
+    it("should not modify shapes when there is no overlap", () => {
+        sketch("xy", () => {
+            const c1 = circle(40);
+            const c2 = circle([200, 0], 40);
+            subtract(c1, c2);
+        });
+        const e = extrude(20);
+        render();
+        // Base circle remains since tool doesn't overlap
+        const shapes = e.getShapes();
+        expect(shapes).toHaveLength(1);
+    });
+});