fluidcad 0.0.28 → 0.0.30

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

@@ -109,4 +109,62 @@ describe("mirror (3D)", () => {
             expect(countShapes(scene)).toBe(1);
         });
     });
+    describe("mirror with .exclude()", () => {
+        it("should skip excluded objects when mirroring everything", () => {
+            sketch("xy", () => {
+                move([20, 0]);
+                rect(30, 30);
+            });
+            const e1 = extrude(10).new();
+            sketch("xy", () => {
+                move([50, 50]);
+                rect(30, 30);
+            });
+            extrude(10).new();
+            // mirror all, but exclude e1 → only e2 gets mirrored
+            // e1 + e2 + mirror(e2) = 3 shapes (e2 is well clear of YZ plane, no fusion)
+            mirror("yz").exclude(e1);
+            const scene = render();
+            expect(countShapes(scene)).toBe(3);
+        });
+        it("should narrow an explicit target list with exclude", () => {
+            sketch("xy", () => {
+                move([20, 0]);
+                rect(30, 30);
+            });
+            const e1 = extrude(10).new();
+            sketch("xy", () => {
+                move([50, 50]);
+                rect(30, 30);
+            });
+            const e2 = extrude(10).new();
+            // explicit target [e1, e2], exclude e2 → only e1 mirrored
+            // e1 + e2 + mirror(e1) = 3
+            mirror("yz", e1, e2).exclude(e2);
+            const scene = render();
+            expect(countShapes(scene)).toBe(3);
+        });
+        it("should accumulate exclusions across chained calls", () => {
+            sketch("xy", () => {
+                move([20, 0]);
+                rect(30, 30);
+            });
+            const e1 = extrude(10).new();
+            sketch("xy", () => {
+                move([50, 50]);
+                rect(30, 30);
+            });
+            const e2 = extrude(10).new();
+            sketch("xy", () => {
+                move([100, 100]);
+                rect(30, 30);
+            });
+            extrude(10).new();
+            // mirror everything but exclude e1 and e2 across two chained .exclude() calls
+            // e1 + e2 + e3 + mirror(e3) = 4 (all on +X side, mirror lands on -X side)
+            mirror("yz").exclude(e1).exclude(e2);
+            const scene = render();
+            expect(countShapes(scene)).toBe(4);
+        });
+    });
 });

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

@@ -106,4 +106,67 @@ describe("mirror (2D)", () => {
             expect(() => local("y")).toThrow();
         });
     });
+    describe("mirror with .exclude()", () => {
+        it("should skip an excluded geometry when mirroring all sketch siblings", () => {
+            sketch("xy", () => {
+                move([30, 0]);
+                const c1 = circle(10);
+                move([30, 50]);
+                const c2 = circle(10);
+                // mirror everything in the sketch but skip c2
+                mirror("y").exclude(c2);
+                // sanity: keep references referenced
+                void c1;
+            });
+            const e = extrude(5);
+            render();
+            const shapes = e.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(3);
+            const bboxes = shapes.map(s => ShapeOps.getBoundingBox(s));
+            // the c2 mirror would have minX < -10 AND minY > 40 — should NOT exist
+            const c2MirrorPresent = bboxes.some(b => b.minX < -10 && b.minY > 40);
+            expect(c2MirrorPresent).toBe(false);
+        });
+        it("should narrow an explicit target list with exclude", () => {
+            sketch("xy", () => {
+                move([30, 0]);
+                const c1 = circle(10);
+                move([30, 50]);
+                const c2 = circle(10);
+                // explicit targets [c1, c2], then exclude c2 → only c1 is mirrored
+                mirror("y", c1, c2).exclude(c2);
+            });
+            const e = extrude(5);
+            render();
+            const shapes = e.getShapes();
+            const bboxes = shapes.map(s => ShapeOps.getBoundingBox(s));
+            // c2 mirror at (-30, 50) should be absent
+            const c2MirrorPresent = bboxes.some(b => b.minX < -10 && b.minY > 40);
+            expect(c2MirrorPresent).toBe(false);
+            // c1 mirror at (-30, 0) should be present
+            const c1MirrorPresent = bboxes.some(b => b.minX < -10 && b.maxY < 40);
+            expect(c1MirrorPresent).toBe(true);
+        });
+        it("should accumulate exclusions across chained calls", () => {
+            sketch("xy", () => {
+                move([30, 0]);
+                const c1 = circle(10);
+                move([30, 50]);
+                const c2 = circle(10);
+                move([30, 100]);
+                const c3 = circle(10);
+                // exclude c1 and c2 in two calls; only c3 should be mirrored
+                mirror("y").exclude(c1).exclude(c2);
+                void c3;
+            });
+            const e = extrude(5);
+            render();
+            const shapes = e.getShapes();
+            const bboxes = shapes.map(s => ShapeOps.getBoundingBox(s));
+            // c1 mirror (-30, 0) absent
+            expect(bboxes.some(b => b.minX < -10 && b.maxY < 40)).toBe(false);
+            // c3 mirror (-30, 100) present
+            expect(bboxes.some(b => b.minX < -10 && b.minY > 90)).toBe(true);
+        });
+    });
 });

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

@@ -130,4 +130,66 @@ describe("rotate", () => {
             expect(bbox.maxY).toBeCloseTo(0, 0);
         });
     });
+    describe("rotate with .exclude()", () => {
+        it("should skip excluded objects when rotating everything", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e1 = extrude(5).new();
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e2 = extrude(5).new();
+            // No explicit target → rotate all, exclude e1 → only e2 rotates
+            rotate("z", 90, true).exclude(e1);
+            render();
+            // e1 still at (0..20, 0..10) — unrotated
+            expect(e1.getShapes()).toHaveLength(1);
+            const e1Bbox = ShapeOps.getBoundingBox(e1.getShapes()[0]);
+            expect(e1Bbox.maxX).toBeCloseTo(20, 0);
+            expect(e1Bbox.maxY).toBeCloseTo(10, 0);
+            // e2 still present (copy=true)
+            expect(e2.getShapes()).toHaveLength(1);
+        });
+        it("should narrow an explicit target list with exclude", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e1 = extrude(5).new();
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e2 = extrude(5).new();
+            // Explicit targets [e1, e2], exclude e2 → only e1 rotated
+            rotate("z", 90, e1, e2).exclude(e2);
+            render();
+            // e1 moved (removed from source), e2 stays
+            expect(e1.getShapes()).toHaveLength(0);
+            expect(e2.getShapes()).toHaveLength(1);
+            const e2Bbox = ShapeOps.getBoundingBox(e2.getShapes()[0]);
+            expect(e2Bbox.maxX).toBeCloseTo(20, 0);
+            expect(e2Bbox.maxY).toBeCloseTo(10, 0);
+        });
+        it("should accumulate exclusions across chained calls", () => {
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e1 = extrude(5).new();
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e2 = extrude(5).new();
+            sketch("xy", () => {
+                rect(20, 10);
+            });
+            const e3 = extrude(5).new();
+            // Rotate all (copy), exclude e1 and e2 across two calls → only e3 rotated copy
+            rotate("z", 90, true).exclude(e1).exclude(e2);
+            render();
+            // e1 and e2 unchanged at (0..20, 0..10)
+            expect(ShapeOps.getBoundingBox(e1.getShapes()[0]).maxY).toBeCloseTo(10, 0);
+            expect(ShapeOps.getBoundingBox(e2.getShapes()[0]).maxY).toBeCloseTo(10, 0);
+            expect(e3.getShapes()).toHaveLength(1);
+        });
+    });
 });

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

@@ -71,4 +71,51 @@ describe("rotate 2D", () => {
             expect(shapes.length).toBeGreaterThanOrEqual(1);
         });
     });
+    describe("rotate (2D) with .exclude()", () => {
+        it("should skip an excluded geometry when rotating all sketch siblings", () => {
+            let rot;
+            sketch("xy", () => {
+                move([30, 0]);
+                const r1 = rect(20, 10);
+                move([30, 50]);
+                const r2 = rect(20, 10);
+                rot = rotate(90, true).exclude(r2);
+                void r1;
+            });
+            render();
+            // Only r1 should have been rotated (r2 excluded)
+            // 1 rotated rect = 4 edges
+            expect(rot.getAddedShapes()).toHaveLength(4);
+        });
+        it("should narrow an explicit target list with exclude", () => {
+            let rot;
+            sketch("xy", () => {
+                move([30, 0]);
+                const r1 = rect(20, 10);
+                move([30, 50]);
+                const r2 = rect(20, 10);
+                rot = rotate(90, true, r1, r2).exclude(r2);
+            });
+            render();
+            // 1 rotated rect = 4 edges
+            expect(rot.getAddedShapes()).toHaveLength(4);
+        });
+        it("should accumulate exclusions across chained calls", () => {
+            let rot;
+            sketch("xy", () => {
+                move([30, 0]);
+                const r1 = rect(20, 10);
+                move([30, 50]);
+                const r2 = rect(20, 10);
+                move([30, 100]);
+                const r3 = rect(20, 10);
+                rot = rotate(90, true).exclude(r1).exclude(r2);
+                void r3;
+            });
+            render();
+            // Only r3 rotated; r1 and r2 excluded
+            // 1 rotated rect = 4 edges
+            expect(rot.getAddedShapes()).toHaveLength(4);
+        });
+    });
 });

package/lib/dist/tests/features/thin-revolve.test.js

@@ -3,7 +3,7 @@ import { setupOC, render } from "../setup.js";
 import sketch from "../../core/sketch.js";
 import revolve from "../../core/revolve.js";
 import extrude from "../../core/extrude.js";
-import { move, rect, circle, line } from "../../core/2d/index.js";
+import { move, rect, circle, line, vLine } from "../../core/2d/index.js";
 import { ShapeProps } from "../../oc/props.js";
 import { EdgeQuery } from "../../oc/edge-query.js";
 describe("thin revolve", () => {
@@ -133,6 +133,42 @@ describe("thin revolve", () => {
             expect(internalFaces.length).toBeGreaterThan(0);
             expect(capFaces.length).toBe(2);
         });
+        it("should classify cap faces for vertical line profile parallel to axis (90 deg)", () => {
+            sketch("xy", () => {
+                move([50, 0]);
+                vLine(100).centered();
+            });
+            const r = revolve("y", -90).thin(20).new();
+            render();
+            const startFaces = r.getState('start-faces');
+            const endFaces = r.getState('end-faces');
+            const sideFaces = r.getState('side-faces');
+            const internalFaces = r.getState('internal-faces');
+            const capFaces = r.getState('cap-faces');
+            expect(startFaces.length).toBe(1);
+            expect(endFaces.length).toBe(1);
+            expect(sideFaces.length).toBe(1);
+            expect(internalFaces.length).toBe(1);
+            expect(capFaces.length).toBe(2);
+        });
+        it("should classify cap faces for vertical line profile parallel to axis (180 deg)", () => {
+            sketch("xy", () => {
+                move([50, 0]);
+                vLine(100).centered();
+            });
+            const r = revolve("y", 180).thin(20).new();
+            render();
+            const startFaces = r.getState('start-faces');
+            const endFaces = r.getState('end-faces');
+            const sideFaces = r.getState('side-faces');
+            const internalFaces = r.getState('internal-faces');
+            const capFaces = r.getState('cap-faces');
+            expect(startFaces.length).toBe(1);
+            expect(endFaces.length).toBe(1);
+            expect(sideFaces.length).toBe(1);
+            expect(internalFaces.length).toBe(1);
+            expect(capFaces.length).toBe(2);
+        });
     });
     describe("remove mode", () => {
         it("should cut a thin-walled revolve from existing geometry", () => {

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

@@ -114,4 +114,67 @@ describe("translate", () => {
             expect(bbox.minX).toBeCloseTo(0, 0);
         });
     });
+    describe("translate with .exclude()", () => {
+        it("should skip excluded objects when translating everything", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e1 = extrude(10).new();
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e2 = extrude(10).new();
+            // No explicit target → translate all, exclude e1 → only e2 moves
+            translate(100, true).exclude(e1);
+            render();
+            // e1 stays at origin
+            expect(e1.getShapes()).toHaveLength(1);
+            const e1Bbox = ShapeOps.getBoundingBox(e1.getShapes()[0]);
+            expect(e1Bbox.minX).toBeCloseTo(0, 0);
+            // e2 was copied to x=100 (original still present because copy=true)
+            expect(e2.getShapes()).toHaveLength(1);
+        });
+        it("should narrow an explicit target list with exclude", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e1 = extrude(10).new();
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e2 = extrude(10).new();
+            // Explicit targets [e1, e2], exclude e2 → only e1 moves
+            translate(100, e1, e2).exclude(e2);
+            render();
+            // e1 moved (removed from source), e2 stays
+            expect(e1.getShapes()).toHaveLength(0);
+            expect(e2.getShapes()).toHaveLength(1);
+            const e2Bbox = ShapeOps.getBoundingBox(e2.getShapes()[0]);
+            expect(e2Bbox.minX).toBeCloseTo(0, 0);
+        });
+        it("should accumulate exclusions across chained calls", () => {
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e1 = extrude(10).new();
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e2 = extrude(10).new();
+            sketch("xy", () => {
+                rect(20, 20);
+            });
+            const e3 = extrude(10).new();
+            // Translate all (copy), exclude e1 and e2 across two calls → only e3 copied
+            translate(200, true).exclude(e1).exclude(e2);
+            render();
+            // All originals preserved (copy=true)
+            expect(e1.getShapes()).toHaveLength(1);
+            expect(e2.getShapes()).toHaveLength(1);
+            expect(e3.getShapes()).toHaveLength(1);
+            // e1 and e2 still at origin
+            expect(ShapeOps.getBoundingBox(e1.getShapes()[0]).minX).toBeCloseTo(0, 0);
+            expect(ShapeOps.getBoundingBox(e2.getShapes()[0]).minX).toBeCloseTo(0, 0);
+        });
+    });
 });

package/lib/dist/tests/perf/record-fusion-history.bench.test.d.ts

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

package/lib/dist/tests/perf/record-fusion-history.bench.test.js

@@ -0,0 +1,77 @@
+import { describe, it } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import cylinder from "../../core/cylinder.js";
+import { circle, rect, move } from "../../core/2d/index.js";
+// Run with `LOG_PERF=1 npm test -- --run lib/tests/perf/` to see the breakdown.
+const LOG = process.env.LOG_PERF === "1";
+function dump(scene, label, target) {
+    if (!LOG)
+        return;
+    const rendered = scene.getRenderedObject(target);
+    const categories = rendered?.profileCategories ?? [];
+    console.log(`\n=== ${label} ===`);
+    console.log(`buildDurationMs=${rendered?.buildDurationMs?.toFixed(1)}ms`);
+    for (const c of categories) {
+        console.log(`  ${c.category.padEnd(30)} ${c.durationMs.toFixed(1)}ms`);
+    }
+}
+describe("perf: record fusion history breakdown", () => {
+    setupOC();
+    it("simple cylinder + extrude fuse", () => {
+        cylinder(20, 20);
+        sketch("xy", () => { circle(8); });
+        const e = extrude(40);
+        const s = render();
+        dump(s, "simple cylinder + extrude(40) fuse", e);
+    });
+    it("box + extrude fuse — bigger result", () => {
+        sketch("xy", () => { rect(80, 80); });
+        extrude(40);
+        sketch("xy", () => { circle(15); });
+        const e = extrude(80);
+        const s = render();
+        dump(s, "box(80,80,40) + extrude(80) fuse", e);
+    });
+    it("complex: many small holes through a big block", () => {
+        sketch("xy", () => { rect(100, 100); });
+        extrude(40);
+        for (let i = 0; i < 5; i++) {
+            for (let j = 0; j < 5; j++) {
+                sketch("xy", () => { move([i * 18 - 36, j * 18 - 36]); circle(3); });
+            }
+        }
+        sketch("xy", () => { circle(40); });
+        const e = extrude(40);
+        const s = render();
+        dump(s, "block + extrude over many holes", e);
+    });
+    it("very complex: big block with N small holes (single fuse)", () => {
+        sketch("xy", () => { rect(200, 200); });
+        extrude(40);
+        const N = 8;
+        sketch("xy", () => {
+            for (let i = 0; i < N; i++) {
+                for (let j = 0; j < N; j++) {
+                    move([i * 22 - 80, j * 22 - 80]);
+                    circle(4);
+                }
+            }
+        });
+        const e = extrude(60);
+        const s = render();
+        dump(s, `block + single extrude with ${N * N} holes`, e);
+    });
+    it("incremental fuses: extrude many small features one-by-one", () => {
+        sketch("xy", () => { rect(150, 150); });
+        extrude(30);
+        let last = null;
+        for (let i = 0; i < 10; i++) {
+            sketch("xy", () => { move([i * 12 - 50, 0]); circle(4); });
+            last = extrude(40);
+        }
+        const s = render();
+        dump(s, "10th incremental extrude (after building up complexity)", last);
+    });
+});