fluidcad 0.0.2

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

@@ -0,0 +1,240 @@
+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 { circle, move, rect } from "../../core/2d/index.js";
+import cylinder from "../../core/cylinder.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+describe("extrude symmetric", () => {
+    setupOC();
+    describe("extrudable", () => {
+        it("should extrude last extrudable by default", () => {
+            const s = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30).symmetric();
+            expect(e.extrudable).toBe(s);
+        });
+        it("should remove the extrudable", () => {
+            const s = sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30).symmetric();
+            render();
+            expect(s.getShapes()).toHaveLength(0);
+        });
+    });
+    describe("symmetric behavior", () => {
+        it("should extrude equally in both directions", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30).symmetric();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minZ).toBeCloseTo(-15, 0);
+            expect(bbox.maxZ).toBeCloseTo(15, 0);
+        });
+        it("should produce a solid with correct height", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(40).symmetric();
+            render();
+            const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
+            const height = bbox.maxZ - bbox.minZ;
+            expect(height).toBeCloseTo(40, 0);
+        });
+    });
+    describe("fuse", () => {
+        it("should fuse intersecting faces by default", () => {
+            sketch("xy", () => {
+                circle([-25, 0], 100);
+                circle([25, 0], 100);
+            });
+            const e = extrude(30).symmetric();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should fuse with existing scene objects by default", () => {
+            cylinder(50, 50);
+            sketch("xy", () => {
+                move([25, 0]);
+                circle(100);
+            });
+            extrude(30).symmetric();
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+        it("should not fuse when new", () => {
+            cylinder(50, 50);
+            sketch("xy", () => {
+                move([0, 0]);
+                circle(100);
+            });
+            extrude(30).symmetric().new();
+            const scene = render();
+            expect(countShapes(scene)).toBe(2);
+        });
+    });
+    describe("startFaces / endFaces", () => {
+        it("should expose start and end faces", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30).symmetric();
+            const sf = e.startFaces();
+            const ef = e.endFaces();
+            addToScene(sf);
+            addToScene(ef);
+            render();
+            expect(sf.getShapes()).toHaveLength(1);
+            expect(sf.getShapes()[0].getType()).toBe("face");
+            expect(ef.getShapes()).toHaveLength(1);
+            expect(ef.getShapes()[0].getType()).toBe("face");
+        });
+        it("start and end faces should be different", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30).symmetric();
+            const sf = e.startFaces();
+            const ef = e.endFaces();
+            addToScene(sf);
+            addToScene(ef);
+            render();
+            expect(sf.getShapes()[0].isSame(ef.getShapes()[0])).toBe(false);
+        });
+        it("start face should be at z=distance/2 and end face at z=-distance/2", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30).symmetric();
+            const sf = e.startFaces();
+            const ef = e.endFaces();
+            addToScene(sf);
+            addToScene(ef);
+            render();
+            const startBBox = ShapeOps.getBoundingBox(sf.getShapes()[0]);
+            expect(startBBox.minZ).toBeCloseTo(15);
+            expect(startBBox.maxZ).toBeCloseTo(15);
+            const endBBox = ShapeOps.getBoundingBox(ef.getShapes()[0]);
+            expect(endBBox.minZ).toBeCloseTo(-15);
+            expect(endBBox.maxZ).toBeCloseTo(-15);
+        });
+        it("should expose specific face by index for separate regions", () => {
+            sketch("xy", () => {
+                circle(40);
+                circle([100, 0], 40);
+            });
+            const e = extrude(30).symmetric();
+            const face0 = e.startFaces(0);
+            const face1 = e.startFaces(1);
+            addToScene(face0);
+            addToScene(face1);
+            render();
+            expect(face0.getShapes()).toHaveLength(1);
+            expect(face1.getShapes()).toHaveLength(1);
+            expect(face0.getShapes()[0].isSame(face1.getShapes()[0])).toBe(false);
+        });
+    });
+    describe("sideFaces", () => {
+        it("should expose side faces spanning full height", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30).symmetric();
+            const sf = e.sideFaces(0, 1, 2, 3);
+            const sf0 = e.sideFaces(0);
+            addToScene(sf);
+            addToScene(sf0);
+            render();
+            expect(sf.getShapes().length).toBeGreaterThanOrEqual(4);
+            const bbox = ShapeOps.getBoundingBox(sf0.getShapes()[0]);
+            expect(bbox.minZ).toBeCloseTo(-15, 0);
+            expect(bbox.maxZ).toBeCloseTo(15, 0);
+        });
+    });
+    describe("startEdges / endEdges", () => {
+        it("should expose start and end edges", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30).symmetric();
+            const se = e.startEdges();
+            const ee = e.endEdges();
+            addToScene(se);
+            addToScene(ee);
+            render();
+            expect(se.getShapes()).toHaveLength(4);
+            expect(ee.getShapes()).toHaveLength(4);
+        });
+        it("should expose specific edge by index", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30).symmetric();
+            const edge0 = e.startEdges(0);
+            const edge1 = e.startEdges(1);
+            addToScene(edge0);
+            addToScene(edge1);
+            render();
+            expect(edge0.getShapes()).toHaveLength(1);
+            expect(edge1.getShapes()).toHaveLength(1);
+            expect(edge0.getShapes()[0].isSame(edge1.getShapes()[0])).toBe(false);
+        });
+    });
+    describe("drill", () => {
+        it("should drill hole when inner shape is nested (default)", () => {
+            sketch("xy", () => {
+                circle(100);
+                circle(40);
+            });
+            const e = extrude(30).symmetric();
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            const solid = shapes[0];
+            expect(solid.getFaces().length).toBeGreaterThan(3);
+        });
+        it("should not drill hole when drill is false", () => {
+            sketch("xy", () => {
+                circle(100);
+                circle(40);
+            });
+            const e = extrude(30).symmetric().drill(false);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            const solid = shapes[0];
+            expect(solid.getFaces()).toHaveLength(3);
+        });
+    });
+    describe("pick", () => {
+        it("should only extrude the picked region", () => {
+            sketch("xy", () => {
+                circle(60);
+                circle([100, 0], 60);
+            });
+            const e = extrude(20).symmetric().pick([0, 0]);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should produce no solid when pick point is outside all regions", () => {
+            sketch("xy", () => {
+                circle(60);
+            });
+            const e = extrude(20).symmetric().pick([500, 500]);
+            render();
+            expect(e.getShapes()).toHaveLength(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,256 @@
+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 rotate from "../../core/rotate.js";
+import { circle, move, rect } from "../../core/2d/index.js";
+import cylinder from "../../core/cylinder.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { face } from "../../filters/index.js";
+describe("extrude to face", () => {
+    setupOC();
+    describe("parallel planar face", () => {
+        it("should extrude up to a parallel planar end face", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(50);
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(30, 30);
+            });
+            const e2 = extrude(e1.endFaces());
+            render();
+            const shapes = e2.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxZ).toBeCloseTo(50, 0);
+        });
+        it("should match the height of the target face", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(20);
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(30, 30);
+            });
+            const e2 = extrude(e1.endFaces());
+            render();
+            const shapes = e2.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxZ).toBeCloseTo(20, 0);
+        });
+    });
+    describe("first-face / last-face", () => {
+        it("should extrude up to the first face in the normal direction", () => {
+            // Thin slab at z=20..21 — its top face center is at z=21
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(50, 50);
+            });
+            extrude(21).endOffset(1).new();
+            // Thin slab at z=50..51
+            sketch("xy", () => {
+                move([200, 100]);
+                rect(50, 50);
+            });
+            extrude(51).endOffset(1).new();
+            // first-face should reach the closest face center (z=20 bottom of first slab)
+            sketch("xy", () => {
+                rect(30, 30);
+            });
+            const e = extrude("first-face");
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            // Should reach the first slab, not the second
+            expect(bbox.maxZ).toBeLessThan(50);
+        });
+        it("should extrude up to the last face in the normal direction", () => {
+            // Short box
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(50, 50);
+            });
+            extrude(30).new();
+            // Tall box
+            sketch("xy", () => {
+                move([200, 100]);
+                rect(50, 50);
+            });
+            extrude(60).new();
+            // last-face should reach the farthest face
+            sketch("xy", () => {
+                rect(30, 30);
+            });
+            const e = extrude("last-face");
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxZ).toBeCloseTo(60, 0);
+        });
+        it("first-face and last-face should produce different heights", () => {
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(50, 50);
+            });
+            extrude(30).new();
+            sketch("xy", () => {
+                move([200, 100]);
+                rect(50, 50);
+            });
+            extrude(80).new();
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const eFirst = extrude("first-face");
+            sketch("xy", () => {
+                move([0, 30]);
+                rect(20, 20);
+            });
+            const eLast = extrude("last-face");
+            render();
+            const firstBBox = ShapeOps.getBoundingBox(eFirst.getShapes()[0]);
+            const lastBBox = ShapeOps.getBoundingBox(eLast.getShapes()[0]);
+            expect(lastBBox.maxZ).toBeGreaterThan(firstBBox.maxZ);
+        });
+    });
+    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
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(50).draft(10);
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(30, 30);
+            });
+            const e2 = extrude(e1.sideFaces(0));
+            render();
+            const shapes = e2.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
+    describe("cylindrical face", () => {
+        it("should extrude up to a cylindrical face", () => {
+            cylinder(50, 80);
+            const cylFace = select(face().cylinder());
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(30, 30);
+            });
+            const e = extrude(cylFace);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
+    describe("inclined cylindrical face", () => {
+        it("should extrude up to a rotated cylindrical face", () => {
+            const cyl = cylinder(50, 80);
+            rotate("y", 45, cyl);
+            const cylFace = select(face().cylinder());
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(30, 30);
+            });
+            const e = extrude(cylFace);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
+    describe("fuse", () => {
+        it("should not fuse with non-intersecting objects", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(50);
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(30, 30);
+            });
+            const e2 = extrude(e1.endFaces());
+            render();
+            // Two solids: the original box and the extruded-to-face box
+            expect(e1.getShapes({}, 'solid')).toHaveLength(1);
+            expect(e2.getShapes({}, 'solid')).toHaveLength(1);
+        });
+        it("should fuse with intersecting objects by default", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(50);
+            sketch("xy", () => {
+                move([25, 10]);
+                rect(30, 30);
+            });
+            extrude(e1.endFaces());
+            const scene = render();
+            // Fused into 1 solid (lazy face selection is not a solid)
+            const solids = scene.getAllSceneObjects().flatMap(o => o.getShapes({}, 'solid'));
+            expect(solids).toHaveLength(1);
+        });
+        it("should not fuse with intersecting objects when fuse is none", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(50);
+            sketch("xy", () => {
+                move([25, 10]);
+                rect(30, 30);
+            });
+            const e2 = extrude(e1.endFaces()).new();
+            render();
+            // Two solids: the original box and the unfused extruded-to-face box
+            expect(e1.getShapes({}, 'solid')).toHaveLength(1);
+            expect(e2.getShapes({}, 'solid')).toHaveLength(1);
+        });
+    });
+    describe("drill", () => {
+        it("should drill hole when inner shape is nested (default)", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(50);
+            sketch("xy", () => {
+                move([200, 0]);
+                circle(100);
+                circle([200, 0], 40);
+            });
+            const e2 = extrude(e1.endFaces());
+            render();
+            const shapes = e2.getShapes();
+            expect(shapes).toHaveLength(1);
+            const solid = shapes[0];
+            expect(solid.getFaces().length).toBeGreaterThan(3);
+        });
+    });
+    describe("pick", () => {
+        it("should only extrude the picked region", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e1 = extrude(50);
+            sketch("xy", () => {
+                move([200, 0]);
+                circle(60);
+                circle([200, 100], 60);
+            });
+            const e2 = extrude(e1.endFaces()).pick([200, 0]);
+            render();
+            const shapes = e2.getShapes();
+            expect(shapes).toHaveLength(1);
+        });
+    });
+});

package/lib/dist/tests/features/extrude-two-distances.test.d.ts

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