fluidcad 0.0.2

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

@@ -0,0 +1,312 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render, addToScene } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import sweep from "../../core/sweep.js";
+import extrude from "../../core/extrude.js";
+import { circle, rect, vLine, hLine, arc } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { ShapeProps } from "../../oc/props.js";
+describe("sweep", () => {
+    setupOC();
+    describe("basic sweep", () => {
+        it("should sweep a circle along a straight line path", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile);
+            render();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should sweep a rect along a straight line path", () => {
+            const profile = sketch("xy", () => {
+                rect(20, 10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile);
+            render();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should produce a solid with positive volume", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile);
+            render();
+            const props = ShapeProps.getProperties(s.getShapes()[0].getShape());
+            expect(props.volumeMm3).toBeGreaterThan(0);
+        });
+    });
+    describe("sweep with curved path", () => {
+        it("should sweep a circle along an arc path", () => {
+            const profile = sketch("xy", () => {
+                circle(5);
+            });
+            const path = sketch("xz", () => {
+                arc(50, 90);
+            });
+            const s = sweep(path, profile);
+            render();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should sweep along a multi-segment path", () => {
+            const profile = sketch("xy", () => {
+                circle(4);
+            });
+            const path = sketch("xz", () => {
+                vLine(30);
+                hLine(30);
+            });
+            const s = sweep(path, profile);
+            render();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            const props = ShapeProps.getProperties(shapes[0].getShape());
+            expect(props.volumeMm3).toBeGreaterThan(0);
+        });
+    });
+    describe("sweep with hollow profile", () => {
+        it("should sweep two nested circles preserving the hole", () => {
+            const profile = sketch("xy", () => {
+                circle(20);
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile);
+            render();
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+            // The hollow sweep should have less volume than a solid sweep
+            const hollowVolume = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            // A solid circle(20) swept 50 would be pi*20^2*50 ≈ 62832
+            const fullCylinderVolume = Math.PI * 20 * 20 * 50;
+            expect(hollowVolume).toBeLessThan(fullCylinderVolume * 0.95);
+            expect(hollowVolume).toBeGreaterThan(0);
+        });
+    });
+    describe("target selection", () => {
+        it("should use the last extrudable when no target is given", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile);
+            render();
+            // When called with explicit target, it should use that
+            expect(s.extrudable).toBe(profile);
+            const shapes = s.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should use the given target over the last extrudable", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile);
+            render();
+            expect(s.extrudable).toBe(profile);
+        });
+    });
+    describe("input consumption", () => {
+        it("should remove extrudable shapes", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            sweep(path, profile);
+            render();
+            expect(profile.getShapes()).toHaveLength(0);
+        });
+        it("should remove path shapes", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            sweep(path, profile);
+            render();
+            expect(path.getShapes()).toHaveLength(0);
+        });
+    });
+    describe("scene shape count", () => {
+        it("should produce a single shape in the scene", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            sweep(path, profile);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+    describe("bounding box", () => {
+        it("should have correct dimensions for a straight sweep", () => {
+            const profile = sketch("xy", () => {
+                circle(10);
+            });
+            const path = sketch("xz", () => {
+                vLine(50);
+            });
+            const s = sweep(path, profile);
+            render();
+            const bbox = ShapeOps.getBoundingBox(s.getShapes()[0]);
+            // Circle diameter 10 (radius 5) swept 50 units along Z
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(10, 0);
+            expect(bbox.maxY - bbox.minY).toBeCloseTo(10, 0);
+            expect(bbox.maxZ - bbox.minZ).toBeCloseTo(50, 0);
+        });
+    });
+    describe("startFaces / endFaces / sideFaces", () => {
+        it("should expose start and end faces", () => {
+            const profile = sketch("xy", () => {
+                rect(20, 10);
+            });
+            const path = sketch("xz", () => {
+                vLine(40);
+            });
+            const s = sweep(path, profile);
+            const sf = s.startFaces();
+            const ef = s.endFaces();
+            addToScene(sf);
+            addToScene(ef);
+            render();
+            const startFaces = sf.getShapes();
+            expect(startFaces.length).toBeGreaterThan(0);
+            expect(startFaces[0].getType()).toBe("face");
+            const endFaces = ef.getShapes();
+            expect(endFaces.length).toBeGreaterThan(0);
+            expect(endFaces[0].getType()).toBe("face");
+        });
+        it("should expose side faces", () => {
+            const profile = sketch("xy", () => {
+                rect(20, 10);
+            });
+            const path = sketch("xz", () => {
+                vLine(40);
+            });
+            const s = sweep(path, profile);
+            const sidf = s.sideFaces();
+            addToScene(sidf);
+            render();
+            const sideFaces = sidf.getShapes();
+            expect(sideFaces.length).toBeGreaterThan(0);
+            for (const f of sideFaces) {
+                expect(f.getType()).toBe("face");
+            }
+        });
+        it("should filter side faces by index", () => {
+            const profile = sketch("xy", () => {
+                rect(20, 10);
+            });
+            const path = sketch("xz", () => {
+                vLine(40);
+            });
+            const s = sweep(path, profile);
+            const allSide = s.sideFaces();
+            const first = s.sideFaces(0);
+            addToScene(allSide);
+            addToScene(first);
+            render();
+            expect(first.getShapes()).toHaveLength(1);
+            expect(first.getShapes()[0].isSame(allSide.getShapes()[0])).toBe(true);
+        });
+    });
+    describe("startEdges / endEdges / sideEdges", () => {
+        it("should expose start and end edges", () => {
+            const profile = sketch("xy", () => {
+                rect(20, 10);
+            });
+            const path = sketch("xz", () => {
+                vLine(40);
+            });
+            const s = sweep(path, profile);
+            const se = s.startEdges();
+            const ee = s.endEdges();
+            addToScene(se);
+            addToScene(ee);
+            render();
+            const startEdges = se.getShapes();
+            expect(startEdges.length).toBeGreaterThan(0);
+            for (const e of startEdges) {
+                expect(e.getType()).toBe("edge");
+            }
+            const endEdges = ee.getShapes();
+            expect(endEdges.length).toBeGreaterThan(0);
+        });
+        it("should expose side edges excluding start/end edges", () => {
+            const profile = sketch("xy", () => {
+                rect(20, 10);
+            });
+            const path = sketch("xz", () => {
+                vLine(40);
+            });
+            const s = sweep(path, profile);
+            const side = s.sideEdges();
+            const se = s.startEdges();
+            const ee = s.endEdges();
+            addToScene(side);
+            addToScene(se);
+            addToScene(ee);
+            render();
+            const sideEdges = side.getShapes();
+            expect(sideEdges.length).toBeGreaterThan(0);
+            const startEdges = se.getShapes();
+            const endEdges = ee.getShapes();
+            for (const s of sideEdges) {
+                const inStart = startEdges.some(e => e.isSame(s));
+                const inEnd = endEdges.some(e => e.isSame(s));
+                expect(inStart).toBe(false);
+                expect(inEnd).toBe(false);
+            }
+        });
+    });
+    describe("fusion", () => {
+        it("should fuse with existing geometry by default", () => {
+            sketch("xy", () => {
+                rect(30, 30);
+            });
+            extrude(20);
+            const profile = sketch("xy", () => {
+                circle(5);
+            });
+            const path = sketch("xz", () => {
+                vLine(40);
+            });
+            sweep(path, profile);
+            const scene = render();
+            // Fused result should be a single shape
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,117 @@
+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 translate from "../../core/translate.js";
+import { rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+describe("translate", () => {
+    setupOC();
+    describe("translate along axes", () => {
+        it("should translate along X", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude(10).new();
+            const t = translate(50, e);
+            render();
+            const shapes = t.getShapes();
+            expect(shapes).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minX).toBeCloseTo(50, 0);
+            expect(bbox.maxX).toBeCloseTo(70, 0);
+        });
+        it("should translate along X and Y", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude(10).new();
+            const t = translate(30, 40, e);
+            render();
+            const shapes = t.getShapes();
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minX).toBeCloseTo(30, 0);
+            expect(bbox.minY).toBeCloseTo(40, 0);
+        });
+        it("should translate along X, Y, and Z", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude(10).new();
+            const t = translate(10, 20, 30, e);
+            render();
+            const shapes = t.getShapes();
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minX).toBeCloseTo(10, 0);
+            expect(bbox.minY).toBeCloseTo(20, 0);
+            expect(bbox.minZ).toBeCloseTo(30, 0);
+        });
+    });
+    describe("translate with point", () => {
+        it("should translate by a point-like offset", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude(10).new();
+            const t = translate([15, 25, 35], e);
+            render();
+            const shapes = t.getShapes();
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.minX).toBeCloseTo(15, 0);
+            expect(bbox.minY).toBeCloseTo(25, 0);
+            expect(bbox.minZ).toBeCloseTo(35, 0);
+        });
+    });
+    describe("move vs copy", () => {
+        it("should move the original (remove from source) by default", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude(10).new();
+            translate(50, e);
+            render();
+            // Original removed, only translated shape remains
+            expect(e.getShapes()).toHaveLength(0);
+        });
+        it("should keep the original when copy is true", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude(10).new();
+            translate(50, true, e);
+            render();
+            // Original preserved
+            expect(e.getShapes()).toHaveLength(1);
+        });
+        it("should produce two shapes in the scene when copy is true", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e = extrude(10).new();
+            translate(50, true, e);
+            const scene = render();
+            // Original + copy = 2
+            expect(countShapes(scene)).toBe(2);
+        });
+    });
+    describe("translate specific target", () => {
+        it("should only translate the specified object", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e1 = extrude(10).new();
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e2 = extrude(10).new();
+            translate(100, e1);
+            render();
+            // e1 moved, e2 stays
+            expect(e1.getShapes()).toHaveLength(0);
+            expect(e2.getShapes()).toHaveLength(1);
+            const bbox = ShapeOps.getBoundingBox(e2.getShapes()[0]);
+            expect(bbox.minX).toBeCloseTo(0, 0);
+        });
+    });
+});

package/lib/dist/tests/global-setup.d.ts

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

package/lib/dist/tests/global-setup.js

@@ -0,0 +1,5 @@
+import { beforeAll } from "vitest";
+import { init } from "../index.js";
+beforeAll(async () => {
+    await init("/tmp/fluidcad-test");
+});

package/lib/dist/tests/math/axis.test.d.ts

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