fluidcad 0.0.21 → 0.0.23

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

@@ -1,6 +1,6 @@
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect } from "vitest";
 import { setupOC, render } from "../setup.js";
-import { getCurrentScene, setCurrentFile } from "../../scene-manager.js";
+import { getCurrentScene } from "../../scene-manager.js";
 import sketch from "../../core/sketch.js";
 import extrude from "../../core/extrude.js";
 import cut from "../../core/cut.js";
@@ -8,84 +8,67 @@ import repeat from "../../core/repeat.js";
 import translate from "../../core/translate.js";
 import { circle, rect } from "../../core/2d/index.js";
 import part from "../../core/part.js";
-import use from "../../core/use.js";
 import { Part } from "../../features/part.js";
 import { Extrude } from "../../features/extrude.js";
 import { Sketch } from "../../features/2d/sketch.js";
 import { countShapes } from "../utils.js";
 describe("part", () => {
     setupOC();
-    beforeEach(() => {
-        // Simulate direct editing: currentFile matches the source location
-        // Since tests don't have .fluid.js stack frames, we set currentFile to empty
-        // so that direct execution tests need special handling
-        setCurrentFile('');
-    });
-    describe("use()", () => {
-        it("should execute a part handle via use()", () => {
-            const handle = part("my-part", () => {
-                sketch("xy", () => {
-                    circle(10);
-                });
-                extrude(20);
+    it("should execute a part callback immediately", () => {
+        part("my-part", () => {
+            sketch("xy", () => {
+                circle(10);
             });
-            // Since there's no .fluid.js source frame, the callback won't auto-execute.
-            // We need use() to trigger it.
-            use(handle);
-            const scene = getCurrentScene();
-            const objects = scene.getAllSceneObjects();
-            // Should have Part, Plane, Sketch, Circle, Extrude
-            const parts = objects.filter(o => o instanceof Part);
-            expect(parts).toHaveLength(1);
-            expect(parts[0].partName).toBe("my-part");
+            extrude(20);
         });
-        it("should produce a solid when used", () => {
-            const handle = part("solid-part", () => {
-                sketch("xy", () => {
-                    circle(10);
-                });
-                extrude(20);
+        const scene = getCurrentScene();
+        const objects = scene.getAllSceneObjects();
+        const parts = objects.filter(o => o instanceof Part);
+        expect(parts).toHaveLength(1);
+        expect(parts[0].partName).toBe("my-part");
+    });
+    it("should produce a solid", () => {
+        part("solid-part", () => {
+            sketch("xy", () => {
+                circle(10);
             });
-            use(handle);
-            render();
-            const scene = getCurrentScene();
-            const objects = scene.getAllSceneObjects();
-            const extrudeObj = objects.find(o => o instanceof Extrude);
-            expect(extrudeObj).toBeDefined();
-            const shapes = extrudeObj.getShapes();
-            expect(shapes.length).toBeGreaterThan(0);
-            expect(shapes[0].getType()).toBe("solid");
+            extrude(20);
         });
+        render();
+        const scene = getCurrentScene();
+        const objects = scene.getAllSceneObjects();
+        const extrudeObj = objects.find(o => o instanceof Extrude);
+        expect(extrudeObj).toBeDefined();
+        const shapes = extrudeObj.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+        expect(shapes[0].getType()).toBe("solid");
     });
     describe("fusion isolation", () => {
         it("should keep two parts as separate solids", () => {
-            const handle1 = part("part1", () => {
+            part("part1", () => {
                 sketch("xy", () => {
                     circle(10);
                 });
                 extrude(20);
             });
-            const handle2 = part("part2", () => {
+            part("part2", () => {
                 sketch("xy", () => {
                     circle(10);
                 });
                 extrude(20);
             });
-            use(handle1);
-            use(handle2);
             render();
             const scene = getCurrentScene();
             const objects = scene.getAllSceneObjects();
             const extrudes = objects.filter(o => o instanceof Extrude);
             expect(extrudes).toHaveLength(2);
-            // Each extrude should have its own solid — they should NOT be fused together
             const shapes1 = extrudes[0].getShapes();
             const shapes2 = extrudes[1].getShapes();
             expect(shapes1.length).toBeGreaterThan(0);
             expect(shapes2.length).toBeGreaterThan(0);
         });
         it("should fuse extrudes within the same part", () => {
-            const handle = part("fusing-part", () => {
+            part("fusing-part", () => {
                 sketch("xy", () => {
                     circle([-5, 0], 10);
                 });
@@ -95,14 +78,11 @@ describe("part", () => {
                 });
                 extrude(20);
             });
-            use(handle);
             render();
             const scene = getCurrentScene();
             const objects = scene.getAllSceneObjects();
             const extrudes = objects.filter(o => o instanceof Extrude);
             expect(extrudes).toHaveLength(2);
-            // The second extrude should have fused with the first (overlapping circles)
-            // So the first extrude's shapes should have been removed (consumed by fusion)
             const shapes1 = extrudes[0].getShapes();
             const shapes2 = extrudes[1].getShapes();
             expect(shapes1).toHaveLength(0);
@@ -111,13 +91,12 @@ describe("part", () => {
     });
     describe("container structure", () => {
         it("should make sketch a child of the part", () => {
-            const handle = part("container-test", () => {
+            part("container-test", () => {
                 sketch("xy", () => {
                     circle(10);
                 });
                 extrude(20);
             });
-            use(handle);
             const scene = getCurrentScene();
             const objects = scene.getAllSceneObjects();
             const partObj = objects.find(o => o instanceof Part);
@@ -153,41 +132,35 @@ describe("part", () => {
             });
             const e2 = extrude(20);
             render();
-            // Second extrude should fuse with first (overlapping)
             const shapes = e2.getShapes();
             expect(shapes.length).toBeGreaterThan(0);
         });
     });
     describe("repeat inside part", () => {
         it("should repeat with explicit objects", () => {
-            const handle = part("repeat-explicit", () => {
+            part("repeat-explicit", () => {
                 sketch("xy", () => {
                     rect(50);
                 });
                 const e = extrude().new();
                 repeat("linear", "x", { count: 3, offset: 80 }, e);
             });
-            use(handle);
             const scene = render();
-            // Original + 2 clones = 3 shapes
             expect(countShapes(scene)).toBe(3);
         });
         it("should repeat with default input (last object)", () => {
-            const handle = part("repeat-default", () => {
+            part("repeat-default", () => {
                 sketch("xy", () => {
                     rect(50);
                 });
                 extrude().new();
                 repeat("linear", "x", { count: 3, offset: 80 });
             });
-            use(handle);
             const scene = render();
             expect(countShapes(scene)).toBe(3);
         });
         it("should not override clone parent-child relationships", () => {
-            // Regression: cloned Sketch children (Rect) must keep Sketch as parent,
-            // not be reparented to the Part container
-            const handle = part("clone-parents", () => {
+            part("clone-parents", () => {
                 sketch("xy", () => {
                     rect(50);
                 });
@@ -198,22 +171,19 @@ describe("part", () => {
                 const c = cut();
                 repeat("linear", "x", { count: 3, offset: 80 }, e, c);
             });
-            use(handle);
             const scene = render();
-            // Should produce 3 complete instances (original + 2 clones)
             expect(countShapes(scene)).toBe(3);
         });
     });
     describe("pick inside part", () => {
         it("should preserve pick meta shapes on extrude inside a part", () => {
-            const handle = part("pick-test", () => {
+            part("pick-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');
@@ -222,78 +192,71 @@ describe("part", () => {
             expect(metaShapes.length).toBeGreaterThan(0);
         });
         it("should preserve pick meta shapes with multiple parts", () => {
-            const handle1 = part("pick-part1", () => {
+            part("pick-part1", () => {
                 sketch("xy", () => {
                     rect(50);
                     circle(20);
                 });
                 extrude().pick();
             });
-            const handle2 = part("pick-part2", () => {
+            part("pick-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');
-            // First extrude (pick) should still have meta shapes
             const metaShapes = extrudeRenders[0].sceneShapes.filter(s => s.isMetaShape);
             expect(metaShapes.length).toBeGreaterThan(0);
         });
     });
-    describe("use() as transform target", () => {
+    describe("part() as transform target", () => {
         it("should return an ISceneObject (Part instance)", () => {
-            const handle = part("ret-test", () => {
+            const result = part("ret-test", () => {
                 sketch("xy", () => { circle(10); });
                 extrude(20);
             });
-            const result = use(handle);
             expect(result).toBeDefined();
             expect(result).toBeInstanceOf(Part);
         });
         it("should translate a Part target", () => {
-            const handle = part("translate-part", () => {
+            const p = part("translate-part", () => {
                 sketch("xy", () => { rect(20, 20); });
                 extrude(10);
             });
-            const p = use(handle);
             translate(50, 0, 0, p);
             const scene = render();
             expect(countShapes(scene)).toBe(1);
         });
         it("should translate-copy a Part target", () => {
-            const handle = part("copy-part", () => {
+            const p = part("copy-part", () => {
                 sketch("xy", () => { rect(20, 20); });
                 extrude(10);
             });
-            const p = use(handle);
             translate(50, 0, 0, true, p);
             const scene = render();
-            // Original + copy = 2 shapes
             expect(countShapes(scene)).toBe(2);
         });
         it("should transform only the targeted Part", () => {
-            const handle = part("multi", (options) => {
-                sketch("xy", () => { rect(options.size, options.size); });
-                extrude(options.size);
+            const p1 = part("multi-a", () => {
+                sketch("xy", () => { rect(10, 10); });
+                extrude(10);
+            });
+            part("multi-b", () => {
+                sketch("xy", () => { rect(20, 20); });
+                extrude(20);
             });
-            const p1 = use(handle, { size: 10 });
-            const p2 = use(handle, { size: 20 });
             translate(100, 0, 0, p1);
             const scene = render();
-            // Both parts should still produce shapes (2 total)
             expect(countShapes(scene)).toBe(2);
         });
         it("should work inline with translate", () => {
-            const handle = part("inline-part", () => {
+            translate(50, 0, 0, part("inline-part", () => {
                 sketch("xy", () => { circle(10); });
                 extrude(20);
-            });
-            translate(50, 0, 0, use(handle));
+            }));
             const scene = render();
             expect(countShapes(scene)).toBe(1);
         });
@@ -304,15 +267,17 @@ describe("part", () => {
             expect(p.isAlwaysVisible()).toBe(true);
         });
     });
-    describe("options", () => {
-        it("should pass options from use() to the part callback", () => {
-            const handle = part("opts-part", (options) => {
-                sketch("xy", () => {
-                    circle(options.radius);
+    describe("parameterized parts via closures", () => {
+        it("should support parameterization through closures", () => {
+            function makePart(radius, height) {
+                return part("opts-part", () => {
+                    sketch("xy", () => {
+                        circle(radius);
+                    });
+                    extrude(height);
                 });
-                extrude(options.height);
-            });
-            use(handle, { radius: 15, height: 30 });
+            }
+            makePart(15, 30);
             render();
             const scene = getCurrentScene();
             const objects = scene.getAllSceneObjects();
@@ -325,15 +290,17 @@ describe("part", () => {
             expect(shapes.length).toBeGreaterThan(0);
             expect(shapes[0].getType()).toBe("solid");
         });
-        it("should allow reusing a part with different options", () => {
-            const handle = part("reusable", (options) => {
-                sketch("xy", () => {
-                    circle(options.size);
+        it("should create separate parts with different parameters", () => {
+            function makePart(name, size) {
+                return part(name, () => {
+                    sketch("xy", () => {
+                        circle(size);
+                    });
+                    extrude(size);
                 });
-                extrude(options.size);
-            });
-            use(handle, { size: 10 });
-            use(handle, { size: 20 });
+            }
+            makePart("reusable-a", 10);
+            makePart("reusable-b", 20);
             render();
             const scene = getCurrentScene();
             const objects = scene.getAllSceneObjects();
@@ -341,16 +308,4 @@ describe("part", () => {
             expect(parts).toHaveLength(2);
         });
     });
-    describe("PartHandle", () => {
-        it("should have correct properties", () => {
-            const handle = part("test-handle", () => { });
-            expect(handle.__fluidcad_part).toBe(true);
-            expect(handle.name).toBe("test-handle");
-            expect(handle._callback).toBeInstanceOf(Function);
-        });
-        it("should throw when use() is given invalid input", () => {
-            expect(() => use(null)).toThrow("use() expects a PartHandle");
-            expect(() => use({})).toThrow("use() expects a PartHandle");
-        });
-    });
 });

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

@@ -222,7 +222,7 @@ describe("select", () => {
                     rect(100, 50);
                 });
                 extrude(30);
-                const sel = select(edge().onPlane("xy", 30));
+                const sel = select(edge().onPlane("xy", { offset: 30 }));
                 render();
                 expect(sel.getShapes()).toHaveLength(4);
             });
@@ -236,6 +236,104 @@ describe("select", () => {
                 render();
                 expect(sel.getShapes()).toHaveLength(8);
             });
+            it("should select edges on offset plane with bothDirections", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges on z=15 or z=-15 — none exist on an extruded box
+                const sel = select(edge().onPlane("xy", { offset: 15, bothDirections: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(0);
+            });
+            it("should select edges with partial match", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true matches edges with at least one vertex on the plane
+                // Bottom 4 edges are fully on XY, plus the 4 vertical edges each have one vertex on XY
+                const sel = select(edge().onPlane("xy", { partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+            it("should exclude edges with partial notOnPlane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // notOnPlane partial: true excludes edges where any vertex touches XY
+                // Only the 4 top edges (z=30) have no vertex on XY
+                const sel = select(edge().notOnPlane("xy", { partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+        });
+        describe("above / below", () => {
+            it("should select edges entirely above a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges above z=10: the 4 top edges (z=30) have both vertices above
+                // The 4 vertical edges straddle z=10, so they don't match
+                const sel = select(edge().above("xy", { offset: 10 }));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+            it("should select edges entirely below a plane", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges below z=10: the 4 bottom edges (z=0) have both vertices below
+                const sel = select(edge().below("xy", { offset: 10 }));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+            it("should not match edges on the plane itself", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Edges above z=0: bottom edges are ON the plane (dist=0), not above
+                // Only top 4 edges are above, vertical edges straddle
+                const sel = select(edge().above("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(4);
+            });
+            it("should select partially above edges", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true — match edges where at least one vertex is above z=0
+                // Top 4 edges (both vertices above) + 4 vertical edges (one vertex above)
+                const sel = select(edge().above("xy", { partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+            it("should select partially below edges", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // partial: true — match edges where at least one vertex is below z=30
+                // Bottom 4 edges (both vertices below) + 4 vertical edges (one vertex below)
+                const sel = select(edge().below("xy", { offset: 30, partial: true }));
+                render();
+                expect(sel.getShapes()).toHaveLength(8);
+            });
+            it("should return empty when no edges match", () => {
+                sketch("xy", () => {
+                    rect(100, 50);
+                });
+                extrude(30);
+                // Nothing is below z=0 on a box sitting on XY
+                const sel = select(edge().below("xy"));
+                render();
+                expect(sel.getShapes()).toHaveLength(0);
+            });
         });
         describe("parallelTo / notParallelTo", () => {
             it("should select edges parallel to a plane", () => {
@@ -369,7 +467,7 @@ describe("select", () => {
             extrude(30);
             // Faces that have both a line edge on XY AND a line edge on XY offset 30
             // The 4 side faces each have edges on both bottom and top planes
-            const sel = select(face().hasEdge(edge().onPlane("xy"), edge().onPlane("xy", 30)));
+            const sel = select(face().hasEdge(edge().onPlane("xy"), edge().onPlane("xy", { offset: 30 })));
             render();
             expect(sel.getShapes()).toHaveLength(4);
         });
@@ -459,7 +557,7 @@ describe("select", () => {
             });
             extrude(30);
             // Edges on bottom OR edges on top
-            const sel = select(edge().onPlane("xy"), edge().onPlane("xy", 30));
+            const sel = select(edge().onPlane("xy"), edge().onPlane("xy", { offset: 30 }));
             render();
             expect(sel.getShapes()).toHaveLength(8);
         });