fluidcad 0.0.2

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

@@ -0,0 +1,163 @@
+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 cylinder from "../../core/cylinder.js";
+import { rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { getEdgesByType, getFacesByType } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { ShapeProps } from "../../oc/props.js";
+import { edge } from "../../filters/index.js";
+describe("fillet", () => {
+    setupOC();
+    describe("basic fillet", () => {
+        it("should fillet edges and produce a valid solid", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            select(edge().verticalTo("xy"));
+            fillet(5);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+        it("should add cylindrical faces for each filleted edge", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Fillet the 4 vertical edges
+            select(edge().verticalTo("xy"));
+            fillet(5);
+            render();
+            const solid = render().getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const cylFaces = getFacesByType(solid, "cylinder");
+            expect(cylFaces).toHaveLength(4);
+        });
+        it("should add arc edges where fillets are applied", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            select(edge().verticalTo("xy"));
+            fillet(5);
+            render();
+            const solid = render().getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const arcEdges = getEdgesByType(solid, "arc");
+            // Each vertical fillet creates 2 arcs (top and bottom)
+            expect(arcEdges).toHaveLength(8);
+        });
+        it("should increase face count compared to original box", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            select(edge().verticalTo("xy"));
+            fillet(5);
+            render();
+            const solid = render().getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Original box: 6 faces. Filleting 4 edges adds 4 cylindrical faces
+            expect(solid.getFaces().length).toBeGreaterThan(6);
+        });
+        it("should reduce volume compared to original box", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            select(edge().verticalTo("xy"));
+            fillet(5);
+            render();
+            const solid = render().getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const props = ShapeProps.getProperties(solid.getShape());
+            expect(props.volumeMm3).toBeLessThan(100 * 50 * 30);
+        });
+        it("should preserve bounding box dimensions", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            select(edge().verticalTo("xy"));
+            fillet(5);
+            render();
+            const solid = render().getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(100, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(50, 0);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(30, 0);
+        });
+    });
+    describe("fillet with explicit selection", () => {
+        it("should fillet only the selected edges", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            // Fillet only the top horizontal edges (4 edges)
+            const sel = select(edge().onPlane("xy", 30));
+            fillet(3, sel);
+            render();
+            const solid = render().getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // 4 top edges filleted → 4 cylindrical faces
+            const cylFaces = getFacesByType(solid, "cylinder");
+            expect(cylFaces).toHaveLength(4);
+        });
+    });
+    describe("fillet on cylinder", () => {
+        it("should fillet a cylinder's circular edges", () => {
+            cylinder(30, 50);
+            select(edge().circle());
+            fillet(5);
+            render();
+            const solid = render().getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid.getFaces().length).toBeGreaterThan(3);
+        });
+    });
+    describe("fillet radius", () => {
+        it("should use default radius of 1", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            select(edge().verticalTo("xy"));
+            fillet();
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+        it("smaller radius should retain more volume", () => {
+            // Small fillet
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            select(edge().verticalTo("xy"));
+            fillet(2);
+            render();
+            const smallSolid = render().getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const smallVol = ShapeProps.getProperties(smallSolid.getShape()).volumeMm3;
+            // Large fillet (new scene from beforeEach)
+            // Can't compare in same test due to scene reset,
+            // just verify volume is less than original
+            expect(smallVol).toBeLessThan(100 * 50 * 30);
+            expect(smallVol).toBeGreaterThan(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,69 @@
+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 { rect } from "../../core/2d/index.js";
+import { getEdgesByType } from "../utils.js";
+describe("fillet2d", () => {
+    setupOC();
+    describe("fillet all corners", () => {
+        it("should fillet all corners of a rectangle", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+                fillet(5);
+            });
+            const e = extrude(20);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            const solid = shapes[0];
+            // Filleted rect produces arc edges on top and bottom faces
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+        it("should replace sharp corners with arcs", () => {
+            const s = sketch("xy", () => {
+                rect(100, 50);
+                fillet(5);
+            });
+            render();
+            // The sketch edges should contain arcs from the fillets
+            const edges = s.getShapes();
+            expect(edges.length).toBeGreaterThan(4);
+        });
+    });
+    describe("fillet specific targets", () => {
+        it("should fillet only the specified geometry", () => {
+            sketch("xy", () => {
+                const r = rect(100, 50);
+                fillet([r], 5);
+            });
+            const e = extrude(20);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            const solid = shapes[0];
+            // Filleted rect on top and bottom: 4 arcs per face = 8 arcs total
+            expect(getEdgesByType(solid, "arc")).toHaveLength(8);
+            // 4 shortened sides per face (8) + 4 vertical edges each split into segments (8) = 16
+            expect(getEdgesByType(solid, "line")).toHaveLength(16);
+        });
+    });
+    describe("fillet radius", () => {
+        it("should use default radius of 1", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+                fillet();
+            });
+            const e = extrude(20);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            const solid = shapes[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,122 @@
+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 fuse from "../../core/fuse.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("fuse", () => {
+    setupOC();
+    describe("fuse specific objects", () => {
+        it("should fuse two intersecting solids into one", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(30).new();
+            sketch("xy", () => {
+                move([50, 0]);
+                rect(100, 50);
+            });
+            const e2 = extrude(30).new();
+            fuse(e1, e2);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+        it("should not fuse non-intersecting solids", () => {
+            sketch("xy", () => {
+                rect(50, 50);
+            });
+            const e1 = extrude(30).new();
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(50, 50);
+            });
+            const e2 = extrude(30).new();
+            fuse(e1, e2);
+            const scene = render();
+            expect(countShapes(scene)).toBe(2);
+        });
+        it("should remove original shapes from fused objects", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(30).new();
+            sketch("xy", () => {
+                move([50, 0]);
+                rect(100, 50);
+            });
+            const e2 = extrude(30).new();
+            fuse(e1, e2);
+            render();
+            expect(e1.getShapes()).toHaveLength(0);
+            expect(e2.getShapes()).toHaveLength(0);
+        });
+        it("should fuse a box and a cylinder", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(30).new();
+            const c = cylinder(30, 30);
+            fuse(e1, c);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+    describe("fuse all", () => {
+        it("should fuse all solids in the scene", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30).new();
+            sketch("xy", () => {
+                move([50, 0]);
+                rect(100, 50);
+            });
+            extrude(30).new();
+            fuse();
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+        it("should fuse multiple overlapping solids into one", () => {
+            sketch("xy", () => {
+                rect(50, 50);
+            });
+            extrude(30).new();
+            sketch("xy", () => {
+                move([25, 0]);
+                rect(50, 50);
+            });
+            extrude(30).new();
+            sketch("xy", () => {
+                move([50, 0]);
+                rect(50, 50);
+            });
+            extrude(30).new();
+            fuse();
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+    describe("fused solid geometry", () => {
+        it("should produce a solid wider than either input", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(30).new();
+            sketch("xy", () => {
+                move([50, 0]);
+                rect(100, 50);
+            });
+            const e2 = extrude(30).new();
+            const f = fuse(e1, e2);
+            render();
+            const solid = f.getShapes()[0];
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // Combined: x from 0 to 150
+            expect(bbox.minX).toBeCloseTo(0, 0);
+            expect(bbox.maxX).toBeCloseTo(150, 0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,80 @@
+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 fuse from "../../core/fuse.js";
+import { circle, move, rect } from "../../core/2d/index.js";
+describe("fuse2d", () => {
+    setupOC();
+    describe("fuse all sketch geometries", () => {
+        it("should fuse overlapping circles into a single outline", () => {
+            sketch("xy", () => {
+                const c1 = circle([-20, 0], 60);
+                const c2 = circle([20, 0], 60);
+                fuse();
+            });
+            const e = extrude(20);
+            render();
+            // Fused sketch produces a single solid
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should fuse overlapping rects into a single outline", () => {
+            sketch("xy", () => {
+                rect(60, 40);
+                move([30, 10]);
+                rect(60, 40);
+                fuse();
+            });
+            const e = extrude(20);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+        });
+    });
+    describe("fuse specific targets", () => {
+        it("should fuse only the specified geometries", () => {
+            sketch("xy", () => {
+                const c1 = circle([-20, 0], 60);
+                const c2 = circle([20, 0], 60);
+                // Third circle far away, not included in fuse
+                circle([200, 0], 60);
+                fuse(c1, c2);
+            });
+            const e = extrude(20);
+            render();
+            // Fused pair + separate circle = 2 solids
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(2);
+        });
+    });
+    describe("fuse removes original edges", () => {
+        it("should remove original edges from fused geometries", () => {
+            const s = sketch("xy", () => {
+                const c1 = circle([-20, 0], 60);
+                const c2 = circle([20, 0], 60);
+                fuse(c1, c2);
+            });
+            render();
+            // Original circle edges should be removed, replaced by fused outline
+            const childShapes = s.getShapes();
+            // Fused edges exist
+            expect(childShapes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("non-overlapping geometries", () => {
+        it("should not change non-overlapping geometries", () => {
+            sketch("xy", () => {
+                circle(40);
+                circle([200, 0], 40);
+                fuse();
+            });
+            const e = extrude(20);
+            render();
+            // Non-overlapping circles remain separate
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(2);
+        });
+    });
+});

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

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