fluidcad 0.0.2

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

@@ -0,0 +1,311 @@
+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 cut from "../../core/cut.js";
+import plane from "../../core/plane.js";
+import cylinder from "../../core/cylinder.js";
+import { circle, move, rect } from "../../core/2d/index.js";
+import { countShapes, getFacesByType, getEdgesByType } from "../utils.js";
+describe("cut", () => {
+    setupOC();
+    describe("cut by distance", () => {
+        it("should cut into an existing solid", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            cut(20);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // A box with a rectangular pocket: 6 original + 4 pocket walls + 1 pocket floor = 11 planar faces
+            expect(getFacesByType(solid, "plane").length).toBeGreaterThan(6);
+            // All faces should be planar (no curves)
+            expect(getFacesByType(solid, "cylinder")).toHaveLength(0);
+        });
+        it("should cut a circular pocket into a box", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([50, 50]);
+                circle(40);
+            });
+            cut(30);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+        it("should remove the extrudable sketch shapes", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            const s = sketch(e.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            cut(20);
+            render();
+            expect(s.getShapes()).toHaveLength(0);
+        });
+    });
+    describe("cut through all", () => {
+        it("should cut all the way through the solid", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                circle(40);
+            });
+            cut();
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            // Through-all circular cut adds a cylindrical face (the hole wall)
+            expect(getFacesByType(solid, "cylinder")).toHaveLength(1);
+            // Circle edges at top and bottom of the hole
+            expect(getEdgesByType(solid, "circle").length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe("section edges", () => {
+        it("should expose section edges", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            const c = cut(20);
+            const edgesObj = c.edges();
+            addToScene(edgesObj);
+            render();
+            const edges = edgesObj.getShapes();
+            expect(edges.length).toBeGreaterThan(0);
+            for (const edge of edges) {
+                expect(edge.getType()).toBe("edge");
+            }
+        });
+        it("should expose specific edge by index", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            const c = cut(20);
+            const edge0 = c.edges(0);
+            const edge1 = c.edges(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);
+        });
+        it("should expose start and end edges for a distance cut", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            const c = cut(20);
+            const se = c.startEdges();
+            const ee = c.endEdges();
+            addToScene(se);
+            addToScene(ee);
+            render();
+            const startEdges = se.getShapes();
+            const endEdges = ee.getShapes();
+            expect(startEdges.length).toBeGreaterThan(0);
+            expect(endEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("fuse scope", () => {
+        it("should only cut the targeted object", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e1 = extrude(50);
+            sketch("xy", () => {
+                move([200, 0]);
+                rect(100, 100);
+            });
+            extrude(50);
+            sketch(e1.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            cut(20).remove(e1);
+            const scene = render();
+            // First box is cut (modified), second box is untouched — 2 shapes
+            expect(countShapes(scene)).toBe(2);
+        });
+    });
+    describe("pick", () => {
+        it("should only cut the picked region", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                circle(30);
+                move([75, 25]);
+                circle(30);
+            });
+            const c = cut(20).pick([25, 25]);
+            render();
+            // The cut should have produced a modified solid
+            const shapes = c.getShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+            expect(shapes[0].getType()).toBe("solid");
+        });
+    });
+    describe("internalFaces", () => {
+        it("should expose internal faces for a rectangular pocket", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            const c = cut(20);
+            const inf = c.internalFaces();
+            addToScene(inf);
+            render();
+            const faces = inf.getShapes();
+            // A rectangular pocket creates 5 internal faces: 4 walls + 1 floor
+            expect(faces.length).toBeGreaterThan(0);
+            for (const f of faces) {
+                expect(f.getType()).toBe("face");
+            }
+        });
+        it("should expose internal faces for a circular pocket", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([50, 50]);
+                circle(40);
+            });
+            const c = cut(30);
+            const inf = c.internalFaces();
+            addToScene(inf);
+            render();
+            const faces = inf.getShapes();
+            // A circular pocket creates internal faces: cylinder wall + floor
+            expect(faces.length).toBeGreaterThan(0);
+        });
+        it("should filter internal faces by index", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            const c = cut(20);
+            const allFaces = c.internalFaces();
+            const first = c.internalFaces(0);
+            addToScene(allFaces);
+            addToScene(first);
+            render();
+            const allShapes = allFaces.getShapes();
+            expect(allShapes.length).toBeGreaterThan(0);
+            expect(first.getShapes()).toHaveLength(1);
+            expect(first.getShapes()[0].isSame(allShapes[0])).toBe(true);
+        });
+    });
+    describe("internalEdges", () => {
+        it("should expose internal edges for a rectangular pocket", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(50);
+            sketch(e.endFaces(), () => {
+                move([25, 25]);
+                rect(50, 50);
+            });
+            const c = cut(20);
+            const ine = c.internalEdges();
+            addToScene(ine);
+            render();
+            const edges = ine.getShapes();
+            // A rectangular pocket has 4 internal edges (vertical wall edges)
+            expect(edges.length).toBeGreaterThan(0);
+            for (const edge of edges) {
+                expect(edge.getType()).toBe("edge");
+            }
+        });
+    });
+    describe("multiple intersecting shapes", () => {
+        it("should expose startEdges for through-all cut with overlapping circles", () => {
+            cylinder(50, 80);
+            sketch(plane("xy", 80), () => {
+                circle([-20, 0], 40);
+                circle([20, 0], 50);
+            });
+            const c = cut();
+            const se = c.startEdges();
+            addToScene(se);
+            render();
+            const startEdges = se.getShapes();
+            expect(startEdges.length).toBeGreaterThan(0);
+            for (const edge of startEdges) {
+                expect(edge.getType()).toBe("edge");
+            }
+        });
+        it("should expose internalFaces for through-all cut with overlapping circles", () => {
+            cylinder(50, 80);
+            sketch(plane("xy", 80), () => {
+                circle([-20, 0], 40);
+                circle([20, 0], 50);
+            });
+            const c = cut();
+            const inf = c.internalFaces();
+            addToScene(inf);
+            render();
+            const faces = inf.getShapes();
+            expect(faces.length).toBeGreaterThan(0);
+            for (const f of faces) {
+                expect(f.getType()).toBe("face");
+            }
+        });
+        it("should expose endEdges for through-all cut with overlapping circles", () => {
+            cylinder(50, 80);
+            sketch(plane("xy", 80), () => {
+                circle([-20, 0], 40);
+                circle([20, 0], 50);
+            });
+            const c = cut();
+            const ee = c.endEdges();
+            addToScene(ee);
+            render();
+            const endEdges = ee.getShapes();
+            expect(endEdges.length).toBeGreaterThan(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,189 @@
+import { describe, it, expect, vi } from "vitest";
+import { setupOC, render } from "../setup.js";
+import { getCurrentScene, getSceneManager } from "../../scene-manager.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import cylinder from "../../core/cylinder.js";
+import trim from "../../core/trim.js";
+import { circle, rect } from "../../core/2d/index.js";
+import { SceneCompare } from "../../rendering/scene-compare.js";
+import { renderScene } from "../../rendering/render.js";
+import { Sketch } from "../../features/2d/sketch.js";
+describe("dispose", () => {
+    setupOC();
+    describe("SceneObject.dispose()", () => {
+        it("should clear state after dispose", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            render();
+            expect(e.getShapes().length).toBeGreaterThan(0);
+            e.dispose();
+            // State is cleared — getState returns undefined for all keys
+            expect(e.getState("addedShapes")).toBeUndefined();
+        });
+        it("should call Shape.dispose() on addedShapes", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            render();
+            const shapes = e.getAddedShapes();
+            expect(shapes.length).toBeGreaterThan(0);
+            const spies = shapes.map(s => vi.spyOn(s, "dispose"));
+            e.dispose();
+            for (const spy of spies) {
+                expect(spy).toHaveBeenCalled();
+            }
+        });
+        it("should call Shape.dispose() on face state values", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            render();
+            const startFaces = e.getState("start-faces");
+            const endFaces = e.getState("end-faces");
+            const sideFaces = e.getState("side-faces");
+            expect(startFaces.length).toBeGreaterThan(0);
+            expect(endFaces.length).toBeGreaterThan(0);
+            expect(sideFaces.length).toBeGreaterThan(0);
+            const allSpies = [...startFaces, ...endFaces, ...sideFaces].map(s => vi.spyOn(s, "dispose"));
+            e.dispose();
+            for (const spy of allSpies) {
+                expect(spy).toHaveBeenCalled();
+            }
+        });
+        it("should not dispose shapes in removedShapes", () => {
+            sketch("xy", () => {
+                circle(50);
+            });
+            const e1 = extrude(30);
+            sketch("xy", () => {
+                circle(50);
+            });
+            const e2 = extrude(30);
+            render();
+            // e1's shapes were removed (fused into e2)
+            const e1Shapes = e1.getAddedShapes();
+            const spies = e1Shapes.map(s => vi.spyOn(s, "dispose"));
+            // Dispose e2 — it has removedShapes referencing e1's shapes
+            e2.dispose();
+            // e1's shapes should NOT have been disposed by e2
+            for (const spy of spies) {
+                expect(spy).not.toHaveBeenCalled();
+            }
+        });
+        it("should be safe to call dispose twice", () => {
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            render();
+            e.dispose();
+            // Second call should not throw
+            expect(() => e.dispose()).not.toThrow();
+        });
+    });
+    describe("SceneCompare disposes unmatched objects", () => {
+        it("should dispose unmatched old scene objects after compare", () => {
+            // Build first scene
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            const scene1 = render();
+            const oldObjects = scene1.getSceneObjects();
+            const spies = oldObjects.map(o => vi.spyOn(o, "dispose"));
+            // Build second scene with completely different geometry
+            getSceneManager().startScene();
+            cylinder(50, 100);
+            const scene2 = getCurrentScene();
+            SceneCompare.compare(scene1, scene2);
+            // All old objects are unmatched (cylinder vs sketch+extrude) — all should be disposed
+            for (const spy of spies) {
+                expect(spy).toHaveBeenCalled();
+            }
+        });
+        it("should not dispose matched old scene objects", () => {
+            // Build first scene
+            cylinder(50, 100);
+            const scene1 = render();
+            const oldObj = scene1.getSceneObjectAt(0);
+            const disposeSpy = vi.spyOn(oldObj, "dispose");
+            // Build second scene with same structure
+            getSceneManager().startScene();
+            cylinder(50, 100);
+            const scene2 = getCurrentScene();
+            SceneCompare.compare(scene1, scene2);
+            // Same structure — old object should NOT be disposed (state was transferred)
+            expect(disposeSpy).not.toHaveBeenCalled();
+        });
+        it("should dispose objects after the first mismatch point", () => {
+            // Build first scene: cylinder + extrude
+            cylinder(50, 100);
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            const e = extrude(30);
+            const scene1 = render();
+            const cylObj = scene1.getSceneObjectAt(0);
+            const cylSpy = vi.spyOn(cylObj, "dispose");
+            const eSpy = vi.spyOn(e, "dispose");
+            // Build second scene: cylinder + different sketch shape
+            getSceneManager().startScene();
+            cylinder(50, 100);
+            sketch("xy", () => {
+                circle(80);
+            });
+            extrude(30);
+            const scene2 = getCurrentScene();
+            SceneCompare.compare(scene1, scene2);
+            // Cylinder matches — should NOT be disposed
+            expect(cylSpy).not.toHaveBeenCalled();
+            // Sketch changed (rect -> circle) so from sketch onwards is unmatched
+            expect(eSpy).toHaveBeenCalled();
+        });
+        it("should mark matched objects as cached in new scene", () => {
+            cylinder(50, 100);
+            const scene1 = render();
+            getSceneManager().startScene();
+            cylinder(50, 100);
+            sketch("xy", () => {
+                rect(100, 50);
+            });
+            extrude(30);
+            const scene2 = getCurrentScene();
+            SceneCompare.compare(scene1, scene2);
+            // Cylinder matched — should be cached
+            const newCyl = scene2.getSceneObjectAt(0);
+            expect(scene2.isCached(newCyl)).toBe(true);
+            // Sketch is new — should not be cached
+            const newSketch = scene2.getSceneObjects().find(o => o instanceof Sketch);
+            expect(scene2.isCached(newSketch)).toBe(false);
+        });
+        it("should not delete shapes shared with matched objects (trim2d scenario)", () => {
+            // Build first scene: sketch with circle + trim
+            sketch("xy", () => {
+                circle(100);
+                trim();
+            });
+            const scene1 = render();
+            // Build second scene: same sketch, trim with different points
+            getSceneManager().startScene();
+            sketch("xy", () => {
+                circle(100);
+                trim([10, 0]);
+            });
+            const scene2 = getCurrentScene();
+            // Compare — circle matches, trim2d does not
+            SceneCompare.compare(scene1, scene2);
+            // Render should succeed — the matched circle's edge must not be deleted
+            expect(() => renderScene(scene2)).not.toThrow();
+            // Verify shapes exist on the scene
+            const rendered = scene2.getRenderedObjects();
+            expect(rendered.length).toBeGreaterThan(0);
+        });
+    });
+});

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

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