fluidcad 0.0.2

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

@@ -0,0 +1,283 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render, addToScene } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import plane from "../../core/plane.js";
+import loft from "../../core/loft.js";
+import { rect, circle } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { ShapeProps } from "../../oc/props.js";
+import { face } from "../../filters/index.js";
+describe("loft", () => {
+    setupOC();
+    describe("loft between two profiles", () => {
+        it("should loft between two rects on parallel planes", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+        it("should span the correct height between profiles", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 60 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            render();
+            const bbox = ShapeOps.getBoundingBox(l.getShapes()[0]);
+            expect(bbox.minZ).toBeCloseTo(0, 0);
+            expect(bbox.maxZ).toBeCloseTo(60, 0);
+        });
+        it("should loft between two circles of different radii", () => {
+            const s1 = sketch("xy", () => {
+                circle(80);
+            });
+            const s2 = sketch(plane("xy", { offset: 50 }), () => {
+                circle(40);
+            });
+            const l = loft(s1, s2);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            // Tapered loft — wider at bottom than top
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            const bottomWidth = 80; // 2 * 40
+            const topWidth = 40; // 2 * 20
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(bottomWidth, -1);
+        });
+        it("should produce a solid with positive volume", () => {
+            const s1 = sketch("xy", () => {
+                circle(60);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                circle(30);
+            });
+            const l = loft(s1, s2);
+            render();
+            const props = ShapeProps.getProperties(l.getShapes()[0].getShape());
+            expect(props.volumeMm3).toBeGreaterThan(0);
+        });
+    });
+    describe("loft between different shapes", () => {
+        it("should loft between a rect and a circle", () => {
+            const s1 = sketch("xy", () => {
+                rect(60, 60).center();
+            });
+            const s2 = sketch(plane("xy", { offset: 50 }), () => {
+                circle(60);
+            });
+            const l = loft(s1, s2);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
+    describe("loft between three profiles", () => {
+        it("should loft through three profiles", () => {
+            const s1 = sketch("xy", () => {
+                circle(60);
+            });
+            const s2 = sketch(plane("xy", { offset: 25 }), () => {
+                circle(100);
+            });
+            const s3 = sketch(plane("xy", { offset: 50 }), () => {
+                circle(60);
+            });
+            const l = loft(s1, s2, s3);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            // Middle profile is wider → the solid should bulge out
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxX - bbox.minX).toBeCloseTo(100, -1); // 2 * 50
+        });
+    });
+    describe("loft removes profile shapes", () => {
+        it("should remove sketch shapes from the profiles", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            loft(s1, s2);
+            render();
+            expect(s1.getShapes()).toHaveLength(0);
+            expect(s2.getShapes()).toHaveLength(0);
+        });
+    });
+    describe("loft produces single shape", () => {
+        it("should produce a single shape in the scene", () => {
+            const s1 = sketch("xy", () => {
+                circle(60);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                circle(40);
+            });
+            loft(s1, s2);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+    describe("startFaces / endFaces / sideFaces", () => {
+        it("should expose start and end faces", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            const sf = l.startFaces();
+            const ef = l.endFaces();
+            addToScene(sf);
+            addToScene(ef);
+            render();
+            const startFaces = sf.getShapes();
+            expect(startFaces).toHaveLength(1);
+            expect(startFaces[0].getType()).toBe("face");
+            const endFaces = ef.getShapes();
+            expect(endFaces).toHaveLength(1);
+            expect(endFaces[0].getType()).toBe("face");
+        });
+        it("start and end faces should be different", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            const sf = l.startFaces();
+            const ef = l.endFaces();
+            addToScene(sf);
+            addToScene(ef);
+            render();
+            const startFace = sf.getShapes()[0];
+            const endFace = ef.getShapes()[0];
+            expect(startFace.isSame(endFace)).toBe(false);
+        });
+        it("should expose side faces", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            const sidf = l.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 faces by index", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            const allSide = l.sideFaces();
+            const first = l.sideFaces(0);
+            addToScene(allSide);
+            addToScene(first);
+            render();
+            expect(first.getShapes()).toHaveLength(1);
+            expect(first.getShapes()[0].isSame(allSide.getShapes()[0])).toBe(true);
+        });
+        it("should filter faces with face filter builder", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            const parallelXY = l.startFaces(face().parallelTo("xy"));
+            addToScene(parallelXY);
+            render();
+            expect(parallelXY.getShapes()).toHaveLength(1);
+        });
+    });
+    describe("startEdges / endEdges / sideEdges", () => {
+        it("should expose start and end edges", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            const se = l.startEdges();
+            const ee = l.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 s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            const side = l.sideEdges();
+            const se = l.startEdges();
+            const ee = l.endEdges();
+            addToScene(side);
+            addToScene(se);
+            addToScene(ee);
+            render();
+            const sideEdges = side.getShapes();
+            expect(sideEdges.length).toBeGreaterThan(0);
+            // Side edges should not include any start or end edges
+            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);
+            }
+        });
+        it("should filter edges by index", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50);
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50);
+            });
+            const l = loft(s1, s2);
+            const allStart = l.startEdges();
+            const first = l.startEdges(0);
+            addToScene(allStart);
+            addToScene(first);
+            render();
+            expect(first.getShapes()).toHaveLength(1);
+            expect(first.getShapes()[0].isSame(allStart.getShapes()[0])).toBe(true);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,112 @@
+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 mirror from "../../core/mirror.js";
+import { move, rect } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+describe("mirror (3D)", () => {
+    setupOC();
+    describe("mirror across standard plane", () => {
+        it("should mirror a solid across the YZ plane", () => {
+            sketch("xy", () => {
+                move([20, 0]);
+                rect(30, 30);
+            });
+            const e = extrude(10).new();
+            mirror("yz", e);
+            const scene = render();
+            // Original + mirrored = 2 shapes (or fused into 1 if overlapping)
+            expect(countShapes(scene)).toBeGreaterThanOrEqual(1);
+        });
+        it("should place the mirrored solid on the opposite side", () => {
+            sketch("xy", () => {
+                move([20, 0]);
+                rect(30, 30);
+            });
+            const e = extrude(10).new();
+            const m = mirror("yz", e);
+            render();
+            const shapes = m.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+            // Original is at x=20..50, mirror across YZ (x=0) → mirrored at x=-50..-20
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxX).toBeCloseTo(-20, 0);
+            expect(bbox.minX).toBeCloseTo(-50, 0);
+        });
+        it("should mirror across the XZ plane", () => {
+            sketch("xy", () => {
+                move([0, 20]);
+                rect(30, 30);
+            });
+            const e = extrude(10).new();
+            const m = mirror("xz", e);
+            render();
+            const shapes = m.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+            // Original at y=20..50, mirrored to y=-50..-20
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxY).toBeCloseTo(-20, 0);
+            expect(bbox.minY).toBeCloseTo(-50, 0);
+        });
+        it("should mirror across the XY plane and fuse", () => {
+            sketch("xy", () => {
+                rect(30, 30);
+            });
+            extrude(20).new();
+            mirror("xy");
+            const scene = render();
+            // Original at z=0..20 fuses with mirror at z=-20..0 → single solid
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            expect(bbox.minZ).toBeCloseTo(-20, 0);
+            expect(bbox.maxZ).toBeCloseTo(20, 0);
+        });
+    });
+    describe("mirror all scene objects", () => {
+        it("should mirror the last object when no target specified", () => {
+            sketch("xy", () => {
+                move([20, 0]);
+                rect(30, 30);
+            });
+            extrude(10).new();
+            mirror("yz");
+            const scene = render();
+            expect(countShapes(scene)).toBe(2);
+        });
+    });
+    describe("mirror specific target", () => {
+        it("should only mirror the specified object", () => {
+            sketch("xy", () => {
+                move([20, 0]);
+                rect(30, 30);
+            });
+            const e1 = extrude(10).new();
+            sketch("xy", () => {
+                move([0, 50]);
+                rect(30, 30);
+            });
+            extrude(10).new();
+            mirror("yz", e1);
+            const scene = render();
+            // e1 + mirror of e1 + e2 = 3
+            expect(countShapes(scene)).toBe(3);
+        });
+    });
+    describe("mirror fuses with existing objects", () => {
+        it("should fuse mirrored solid with adjacent objects", () => {
+            // Box centered on YZ plane — mirror across YZ should fuse with original
+            sketch("xy", () => {
+                rect(30, 30);
+            });
+            extrude(10).new();
+            mirror("yz");
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,75 @@
+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 mirror from "../../core/mirror.js";
+import { move, rect, circle } from "../../core/2d/index.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+describe("mirror (2D)", () => {
+    setupOC();
+    describe("mirror sketch geometry across axis", () => {
+        it("should mirror a circle across the Y axis", () => {
+            sketch("xy", () => {
+                move([30, 0]);
+                const c = circle(20);
+                mirror("y", c);
+            });
+            const e = extrude(10);
+            render();
+            const shapes = e.getShapes();
+            // Original circle + mirrored circle → should produce solids on both sides
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+            // Overall bbox should span negative X (mirrored) and positive X (original)
+            const allBBoxes = shapes.map(s => ShapeOps.getBoundingBox(s));
+            const minX = Math.min(...allBBoxes.map(b => b.minX));
+            const maxX = Math.max(...allBBoxes.map(b => b.maxX));
+            expect(minX).toBeLessThan(0);
+            expect(maxX).toBeGreaterThan(0);
+        });
+        it("should mirror a rect across the X axis", () => {
+            sketch("xy", () => {
+                move([0, 20]);
+                const r = rect(30, 20);
+                mirror("x", r);
+            });
+            const e = extrude(10);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(1);
+            const allBBoxes = shapes.map(s => ShapeOps.getBoundingBox(s));
+            const minY = Math.min(...allBBoxes.map(b => b.minY));
+            const maxY = Math.max(...allBBoxes.map(b => b.maxY));
+            expect(minY).toBeLessThan(0);
+            expect(maxY).toBeGreaterThan(0);
+        });
+    });
+    describe("mirror produces shapes", () => {
+        it("should add mirrored edges to the sketch", () => {
+            const m = { ref: null };
+            sketch("xy", () => {
+                move([30, 0]);
+                const c = circle(20);
+                m.ref = mirror("y", c);
+            });
+            render();
+            // The mirror object should have produced shapes
+            expect(m.ref.getAddedShapes().length).toBeGreaterThan(0);
+        });
+    });
+    describe("mirror specific geometry", () => {
+        it("should mirror only the specified geometry", () => {
+            sketch("xy", () => {
+                move([30, 0]);
+                const c1 = circle(20);
+                move([0, 50]);
+                circle(20);
+                mirror("y", c1);
+            });
+            const e = extrude(10);
+            render();
+            // Should have shapes from original c1 + mirrored c1 + c2
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+});

package/lib/dist/tests/features/part-pick.test.d.ts

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

package/lib/dist/tests/features/part-pick.test.js

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { setupOC, render } from "../setup.js";
+import { setCurrentFile } from "../../scene-manager.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import { circle, rect } from "../../core/2d/index.js";
+import part from "../../core/part.js";
+import use from "../../core/use.js";
+describe("pick inside part", () => {
+    setupOC();
+    beforeEach(() => {
+        setCurrentFile('');
+    });
+    it("pick outside part should have meta shapes", () => {
+        sketch("xy", () => {
+            rect(50);
+            circle(20);
+        });
+        extrude().pick();
+        const scene = render();
+        const rendered = scene.getRenderedObjects();
+        const extrudeRender = rendered.find(r => r.type === 'extrude');
+        console.log("OUTSIDE PART pick - extrude shapes:", extrudeRender?.sceneShapes.length, "meta:", extrudeRender?.sceneShapes.filter(s => s.isMetaShape).length);
+        // Should have meta shapes (pick regions)
+        expect(extrudeRender).toBeDefined();
+        const metaShapes = extrudeRender.sceneShapes.filter(s => s.isMetaShape);
+        expect(metaShapes.length).toBeGreaterThan(0);
+    });
+    it("pick inside part should have meta shapes", () => {
+        const handle = part("test", () => {
+            sketch("xy", () => {
+                rect(50);
+                circle(20);
+            });
+            extrude().pick();
+        });
+        use(handle);
+        const scene = render();
+        const rendered = scene.getRenderedObjects();
+        const extrudeRender = rendered.find(r => r.type === 'extrude');
+        console.log("INSIDE PART pick - extrude shapes:", extrudeRender?.sceneShapes.length, "meta:", extrudeRender?.sceneShapes.filter(s => s.isMetaShape).length);
+        expect(extrudeRender).toBeDefined();
+        const metaShapes = extrudeRender.sceneShapes.filter(s => s.isMetaShape);
+        expect(metaShapes.length).toBeGreaterThan(0);
+    });
+    it("pick inside part with second part should have meta shapes", () => {
+        const handle1 = part("part1", () => {
+            sketch("xy", () => {
+                rect(50);
+                circle(20);
+            });
+            extrude().pick();
+        });
+        const handle2 = part("part2", () => {
+            sketch("xy", () => {
+                circle(10);
+            });
+            extrude();
+        });
+        use(handle1);
+        use(handle2);
+        const scene = render();
+        const rendered = scene.getRenderedObjects();
+        const extrudeRenders = rendered.filter(r => r.type === 'extrude');
+        console.log("TWO PARTS pick - extrude count:", extrudeRenders.length);
+        for (const er of extrudeRenders) {
+            console.log("  shapes:", er.sceneShapes.length, "meta:", er.sceneShapes.filter(s => s.isMetaShape).length, "hasError:", er.hasError, er.errorMessage || '');
+        }
+        // First extrude (pick) should have meta shapes
+        const metaShapes = extrudeRenders[0].sceneShapes.filter(s => s.isMetaShape);
+        expect(metaShapes.length).toBeGreaterThan(0);
+    });
+});

package/lib/dist/tests/features/part-repeat.test.d.ts

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

package/lib/dist/tests/features/part-repeat.test.js

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { setupOC, render } from "../setup.js";
+import { setCurrentFile } from "../../scene-manager.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import cut from "../../core/cut.js";
+import repeat from "../../core/repeat.js";
+import { circle, rect } from "../../core/2d/index.js";
+import part from "../../core/part.js";
+import use from "../../core/use.js";
+import { countShapes } from "../utils.js";
+describe("repeat inside part", () => {
+    setupOC();
+    beforeEach(() => {
+        setCurrentFile('');
+    });
+    it("repeat with explicit objects outside part", () => {
+        sketch("xy", () => {
+            rect(50);
+        });
+        const e = extrude();
+        sketch(e.endFaces(), () => {
+            circle(20);
+        });
+        const c = cut();
+        repeat("linear", "x", { count: 3, offset: 80 }, e, c);
+        const scene = render();
+        const shapeCount = countShapes(scene);
+        console.log("OUTSIDE PART explicit:", shapeCount);
+        expect(shapeCount).toBeGreaterThan(0);
+    });
+    it("repeat with default input outside part", () => {
+        sketch("xy", () => {
+            rect(50);
+        });
+        const e = extrude();
+        sketch(e.endFaces(), () => {
+            circle(20);
+        });
+        const c = cut();
+        repeat("linear", "x", { count: 3, offset: 80 });
+        const scene = render();
+        const shapeCount = countShapes(scene);
+        console.log("OUTSIDE PART default:", shapeCount);
+        expect(shapeCount).toBeGreaterThan(0);
+    });
+    it("repeat with explicit objects inside part", () => {
+        const handle = part("test", () => {
+            sketch("xy", () => {
+                rect(50);
+            });
+            const e = extrude();
+            sketch(e.endFaces(), () => {
+                circle(20);
+            });
+            const c = cut();
+            repeat("linear", "x", { count: 3, offset: 80 }, e, c);
+        });
+        use(handle);
+        const scene = render();
+        const shapeCount = countShapes(scene);
+        console.log("INSIDE PART explicit:", shapeCount);
+        expect(shapeCount).toBeGreaterThan(0);
+    });
+    it("repeat with default input inside part", () => {
+        const handle = part("test", () => {
+            sketch("xy", () => {
+                rect(50);
+            });
+            const e = extrude();
+            sketch(e.endFaces(), () => {
+                circle(20);
+            });
+            const c = cut();
+            repeat("linear", "x", { count: 3, offset: 80 });
+        });
+        use(handle);
+        const scene = render();
+        const shapeCount = countShapes(scene);
+        console.log("INSIDE PART default:", shapeCount);
+        expect(shapeCount).toBeGreaterThan(0);
+    });
+    it("simple repeat with default input inside part", () => {
+        const handle = part("test", () => {
+            sketch("xy", () => {
+                rect(50);
+            });
+            const e = extrude().fuse("none");
+            repeat("linear", "x", { count: 3, offset: 80 });
+        });
+        use(handle);
+        const scene = render();
+        const shapeCount = countShapes(scene);
+        console.log("INSIDE PART simple default:", shapeCount);
+        // Should have 3 shapes (original + 2 clones)
+        expect(shapeCount).toBe(3);
+    });
+    it("simple repeat with default input outside part", () => {
+        sketch("xy", () => {
+            rect(50);
+        });
+        const e = extrude().fuse("none");
+        repeat("linear", "x", { count: 3, offset: 80 });
+        const scene = render();
+        const shapeCount = countShapes(scene);
+        console.log("OUTSIDE PART simple default:", shapeCount);
+        expect(shapeCount).toBe(3);
+    });
+});

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

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