fluidcad 0.0.2

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

@@ -0,0 +1,337 @@
+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 cylinder from "../../core/cylinder.js";
+import { circle, rect } from "../../core/2d/index.js";
+import { face, edge } from "../../filters/index.js";
+describe("select", () => {
+    setupOC();
+    describe("face filters", () => {
+        describe("onPlane / notOnPlane", () => {
+            it("should select faces on a specific plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                const sel = select(face().onPlane("xy"));
+                render();
+                const shapes = sel.getShapes();
+                // Box has 1 face on XY (bottom)
+                expect(shapes).toHaveLength(1);
+                expect(shapes[0].getType()).toBe("face");
+            });
+            it("should select faces on an offset plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                const sel = select(face().onPlane("xy", 30));
+                render();
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(1);
+            });
+            it("should select faces NOT on a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                const onXY = select(face().onPlane("xy"));
+                const notOnXY = select(face().notOnPlane("xy"));
+                render();
+                const onShapes = onXY.getShapes();
+                const notOnShapes = notOnXY.getShapes();
+                // Box has 1 face on XY (bottom), 5 not on XY (top + 4 sides)
+                expect(onShapes).toHaveLength(1);
+                expect(notOnShapes).toHaveLength(5);
+                // No overlap
+                for (const s of onShapes) {
+                    expect(notOnShapes.some(ns => ns.isSame(s))).toBe(false);
+                }
+            });
+        });
+        describe("parallelTo / notParallelTo", () => {
+            it("should select faces parallel to a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Top and bottom faces are parallel to XY
+                const sel = select(face().parallelTo("xy"));
+                render();
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(2);
+            });
+            it("should select faces not parallel to a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // 4 side faces are not parallel to XY
+                const sel = select(face().notParallelTo("xy"));
+                render();
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(4);
+            });
+        });
+        describe("circle / notCircle", () => {
+            it("should select circular faces", () => {
+                cylinder(30, 50);
+                const sel = select(face().circle());
+                render();
+                // Cylinder has 2 circular faces (top and bottom)
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(2);
+            });
+            it("should select circular faces with specific diameter", () => {
+                cylinder(30, 50);
+                const sel = select(face().circle(60));
+                render();
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(2);
+            });
+            it("should not match circles with wrong diameter", () => {
+                cylinder(30, 50);
+                const sel = select(face().circle(1998));
+                render();
+                expect(sel.getShapes()).toHaveLength(0);
+            });
+            it("should select non-circular faces", () => {
+                cylinder(30, 50);
+                const sel = select(face().notCircle());
+                render();
+                // The cylindrical side face is not circular
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(1);
+            });
+        });
+        describe("cylinder / notCylinder", () => {
+            it("should select cylindrical faces", () => {
+                cylinder(30, 50);
+                const sel = select(face().cylinder());
+                render();
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(1);
+            });
+            it("should select cylindrical faces with specific diameter", () => {
+                cylinder(30, 50);
+                const sel = select(face().cylinder(60));
+                render();
+                expect(sel.getShapes()).toHaveLength(1);
+            });
+            it("should select non-cylindrical faces", () => {
+                cylinder(30, 50);
+                const sel = select(face().notCylinder());
+                render();
+                // Top and bottom circular faces are not cylindrical surfaces
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(2);
+            });
+        });
+        describe("cone / notCone", () => {
+            it("should select conical faces from a drafted extrusion", () => {
+                sketch("xy", () => {
+                    circle(60);
+                });
+                extrude(50).draft(10);
+                const sel = select(face().cone());
+                render();
+                // Drafted cylinder has 1 conical side face
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(1);
+            });
+            it("should select non-conical faces", () => {
+                sketch("xy", () => {
+                    circle(60);
+                });
+                extrude(50).draft(10);
+                const sel = select(face().notCone());
+                render();
+                // 2 non-conical faces (top and bottom circles)
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(2);
+            });
+        });
+    });
+    describe("edge filters", () => {
+        describe("onPlane / notOnPlane", () => {
+            it("should select edges on a specific plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                const sel = select(edge().onPlane("xy"));
+                render();
+                const shapes = sel.getShapes();
+                expect(shapes).toHaveLength(4);
+                for (const s of shapes) {
+                    expect(s.getType()).toBe("edge");
+                }
+            });
+            it("should select edges on an offset plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                const sel = select(edge().onPlane("xy", 30));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+            it("should select edges NOT on a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Box has 12 edges total, 4 on xy, 4 on xy+30, 4 vertical
+                const sel = select(edge().notOnPlane("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+        });
+        describe("parallelTo / notParallelTo", () => {
+            it("should select edges parallel to a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges parallel to XY = all horizontal edges (top + bottom = 8)
+                const sel = select(edge().parallelTo("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+            it("should select edges not parallel to a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // 4 vertical edges are not parallel to XY
+                const sel = select(edge().notParallelTo("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+        });
+        describe("verticalTo / notVerticalTo", () => {
+            it("should select edges vertical to a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Vertical edges aligned with XY normal (Z direction) = 4
+                const sel = select(edge().verticalTo("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+            it("should select edges not vertical to a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // 8 horizontal edges
+                const sel = select(edge().notVerticalTo("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+        });
+        describe("line / notLine", () => {
+            it("should select straight edges", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                const sel = select(edge().line());
+                render();
+                // All 12 edges of a box are lines
+                expect(sel.getShapes()).toHaveLength(12);
+            });
+            it("should select non-line edges from a cylinder", () => {
+                cylinder(30, 50);
+                const sel = select(edge().notLine());
+                render();
+                // Cylinder has 2 circular edges (top and bottom)
+                expect(sel.getShapes()).toHaveLength(2);
+            });
+        });
+        describe("circle / notCircle", () => {
+            it("should select circular edges", () => {
+                cylinder(30, 50);
+                const sel = select(edge().circle());
+                render();
+                expect(sel.getShapes()).toHaveLength(2);
+            });
+            it("should select circular edges with specific diameter", () => {
+                cylinder(30, 50);
+                const sel = select(edge().circle(60));
+                render();
+                expect(sel.getShapes()).toHaveLength(2);
+            });
+        });
+    });
+    describe("AND logic (chained filters)", () => {
+        it("should match faces satisfying all chained filters", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Parallel to XY AND on plane at z=30 → just the top face
+            const sel = select(face().parallelTo("xy").onPlane("xy", 30));
+            render();
+            expect(sel.getShapes()).toHaveLength(1);
+        });
+        it("should return empty when AND conditions are contradictory", () => {
+            cylinder(30, 50);
+            // circle AND cylinder is impossible (different surface types)
+            const sel = select(face().circle().cylinder());
+            render();
+            expect(sel.getShapes()).toHaveLength(0);
+        });
+        it("should chain edge filters with AND logic", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Lines on the bottom face (z=0)
+            const sel = select(edge().line().onPlane("xy"));
+            render();
+            expect(sel.getShapes()).toHaveLength(4);
+        });
+    });
+    describe("OR logic (multiple builders)", () => {
+        it("should match faces satisfying any builder", () => {
+            cylinder(30, 50);
+            // Circle faces OR cylindrical faces → all 3 faces
+            const sel = select(face().circle(), face().cylinder());
+            render();
+            expect(sel.getShapes()).toHaveLength(3);
+        });
+        it("should deduplicate results across builders", () => {
+            cylinder(30, 50);
+            // Both builders match the same circular faces
+            const sel = select(face().circle(), face().circle());
+            render();
+            // Should still return 2, not 4
+            expect(sel.getShapes()).toHaveLength(2);
+        });
+        it("should combine edge filters with OR logic", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Edges on bottom OR edges on top
+            const sel = select(edge().onPlane("xy"), edge().onPlane("xy", 30));
+            render();
+            expect(sel.getShapes()).toHaveLength(8);
+        });
+        it("should combine AND within OR", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // (parallel to XY AND on z=0) OR (vertical edges)
+            const sel = select(face().parallelTo("xy").onPlane("xy"), face().notParallelTo("xy"));
+            render();
+            // 1 bottom face + 4 side faces = 5
+            expect(sel.getShapes()).toHaveLength(5);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,230 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render, addToScene } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import shell from "../../core/shell.js";
+import select from "../../core/select.js";
+import cylinder from "../../core/cylinder.js";
+import { rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeProps } from "../../oc/props.js";
+import { face } from "../../filters/index.js";
+describe("shell", () => {
+    setupOC();
+    describe("basic shell", () => {
+        it("should hollow out a box by removing the top face", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            select(face().onPlane("xy", 50));
+            shell(5);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Shelled box has more faces than a solid box (inner walls)
+            expect(solid.getFaces().length).toBeGreaterThan(6);
+        });
+        it("should reduce volume compared to the original solid", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            select(face().onPlane("xy", 50));
+            shell(5);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const props = ShapeProps.getProperties(solid.getShape());
+            // Hollow box volume should be less than solid box (100*100*50 = 500000)
+            expect(props.volumeMm3).toBeLessThan(500000);
+            expect(props.volumeMm3).toBeGreaterThan(0);
+        });
+    });
+    describe("shell with explicit selection", () => {
+        it("should shell using an explicit face selection", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            const sel = select(face().onPlane("xy", 50));
+            shell(3, sel);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid.getFaces().length).toBeGreaterThan(6);
+        });
+    });
+    describe("shell thickness", () => {
+        it("should use default thickness of 2.5", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            select(face().onPlane("xy", 50));
+            shell();
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid.getFaces().length).toBeGreaterThan(6);
+        });
+        it("should produce thinner walls with smaller thickness", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            select(face().onPlane("xy", 50));
+            shell(2);
+            render();
+            const solid2 = [...render().getAllSceneObjects()]
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Re-run with a thicker shell to compare
+            // (we can't easily compare two shells in one test due to scene reset,
+            // so just verify it produces a valid shelled solid)
+            expect(solid2).toBeDefined();
+        });
+    });
+    describe("shell on cylinder", () => {
+        it("should hollow out a cylinder", () => {
+            cylinder(50, 80);
+            select(face().onPlane("xy", 80));
+            shell(5);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Hollow cylinder has more faces than a solid cylinder (3)
+            expect(solid.getFaces().length).toBeGreaterThan(3);
+        });
+    });
+    describe("shell removes selection shapes", () => {
+        it("should remove the face selection after shelling", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            const sel = select(face().onPlane("xy", 50));
+            shell(5, sel);
+            render();
+            expect(sel.getShapes()).toHaveLength(0);
+        });
+    });
+    describe("internalFaces", () => {
+        it("should expose internal faces of a shelled box", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            select(face().onPlane("xy", 50));
+            const s = shell(5);
+            const inf = s.internalFaces();
+            addToScene(inf);
+            render();
+            const faces = inf.getShapes();
+            expect(faces.length).toBeGreaterThan(0);
+            for (const f of faces) {
+                expect(f.getType()).toBe("face");
+            }
+        });
+        it("should expose internal faces of a shelled cylinder", () => {
+            cylinder(50, 80);
+            select(face().onPlane("xy", 80));
+            const s = shell(5);
+            const inf = s.internalFaces();
+            addToScene(inf);
+            render();
+            const faces = inf.getShapes();
+            expect(faces.length).toBeGreaterThan(0);
+        });
+        it("should filter internal faces by index", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            select(face().onPlane("xy", 50));
+            const s = shell(5);
+            const allFaces = s.internalFaces();
+            const first = s.internalFaces(0);
+            addToScene(allFaces);
+            addToScene(first);
+            render();
+            const allShapes = allFaces.getShapes();
+            expect(allShapes.length).toBeGreaterThan(0);
+            expect(first.getShapes()).toHaveLength(1);
+            expect(first.getShapes()[0].isSame(allShapes[0])).toBe(true);
+        });
+    });
+    describe("internalEdges", () => {
+        it("should expose internal edges of a shelled box", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            select(face().onPlane("xy", 50));
+            const s = shell(5);
+            const ine = s.internalEdges();
+            addToScene(ine);
+            render();
+            const edges = ine.getShapes();
+            expect(edges.length).toBeGreaterThan(0);
+            for (const e of edges) {
+                expect(e.getType()).toBe("edge");
+            }
+        });
+        it("should filter internal edges by index", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            select(face().onPlane("xy", 50));
+            const s = shell(5);
+            const allEdges = s.internalEdges();
+            const first = s.internalEdges(0);
+            addToScene(allEdges);
+            addToScene(first);
+            render();
+            const allShapes = allEdges.getShapes();
+            expect(allShapes.length).toBeGreaterThan(0);
+            expect(first.getShapes()).toHaveLength(1);
+            expect(first.getShapes()[0].isSame(allShapes[0])).toBe(true);
+        });
+    });
+    describe("shell with multiple selections", () => {
+        it("should shell a box by removing two faces", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            const sel1 = select(face().onPlane("xy", 50));
+            const sel2 = select(face().onPlane("xy", 0));
+            shell(5, sel1, sel2);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid.getFaces().length).toBeGreaterThan(6);
+        });
+        it("should remove all selection shapes after shelling with multiple selections", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            const sel1 = select(face().onPlane("xy", 50));
+            const sel2 = select(face().onPlane("xy", 0));
+            shell(5, sel1, sel2);
+            render();
+            expect(sel1.getShapes()).toHaveLength(0);
+            expect(sel2.getShapes()).toHaveLength(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,103 @@
+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 cylinder from "../../core/cylinder.js";
+import { move, rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+describe("subtract", () => {
+    setupOC();
+    describe("basic subtraction", () => {
+        it("should subtract one solid from another", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const box = extrude(50).new();
+            const cyl = cylinder(20, 50);
+            const s = subtract(box, cyl);
+            render();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            // Subtracted solid should have more faces than a simple box
+            const solid = shapes[0];
+            expect(solid.getFaces().length).toBeGreaterThan(6);
+        });
+        it("should remove original shapes from both operands", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const box = extrude(50).new();
+            const cyl = cylinder(20, 50);
+            subtract(box, cyl);
+            render();
+            expect(box.getShapes()).toHaveLength(0);
+            expect(cyl.getShapes()).toHaveLength(0);
+        });
+        it("should produce a single solid in the scene", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const box = extrude(50).new();
+            const cyl = cylinder(20, 50);
+            subtract(box, cyl);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+    describe("subtraction geometry", () => {
+        it("should preserve outer dimensions of the stock", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const box = extrude(50).new();
+            const cyl = cylinder(20, 50);
+            const s = subtract(box, cyl);
+            render();
+            const bbox = ShapeOps.getBoundingBox(s.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(0, 0);
+            expect(bbox.maxX).toBeCloseTo(100, 0);
+            expect(bbox.minY).toBeCloseTo(0, 0);
+            expect(bbox.maxY).toBeCloseTo(100, 0);
+            expect(bbox.maxZ).toBeCloseTo(50, 0);
+        });
+        it("should subtract a smaller box from a larger box", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const bigBox = extrude(50).new();
+            sketch("xy", () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            const smallBox = extrude(50).new();
+            const s = subtract(bigBox, smallBox);
+            render();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            // U-shaped result should have more than 6 faces
+            const solid = shapes[0];
+            expect(solid.getFaces().length).toBeGreaterThan(6);
+        });
+        it("should handle non-intersecting solids", () => {
+            sketch("xy", () => {
+                rect(50, 50);
+            });
+            const box = extrude(30).new();
+            sketch("xy", () => {
+                move([200, 200]);
+                rect(50, 50);
+            });
+            const farBox = extrude(30).new();
+            const s = subtract(box, farBox);
+            render();
+            // Stock should remain unchanged as a simple box
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            const solid = shapes[0];
+            expect(solid.getFaces()).toHaveLength(6);
+        });
+    });
+});

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

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