fluidcad 0.0.21 → 0.0.22

package/lib/dist/rendering/render.js

@@ -2,6 +2,7 @@ import { MeshBuilder } from "./mesh-builder.js";
 import { PlaneObjectBase } from "../features/plane-renderable-base.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
+import { transformMeshes } from "./mesh-transform.js";
 const meshBuilder = new MeshBuilder();
 function renderSceneObject(obj, scene, buildDurationMs) {
     const hasError = !!obj.getError();
@@ -12,7 +13,18 @@ function renderSceneObject(obj, scene, buildDurationMs) {
         for (const shape of sceneShapes) {
             let meshes = shape.getMeshes();
             if (!meshes) {
-                meshes = meshBuilder.build(shape);
+                const meshSource = shape.getMeshSource();
+                if (meshSource) {
+                    let sourceMeshes = meshSource.shape.getMeshes();
+                    if (!sourceMeshes) {
+                        sourceMeshes = meshBuilder.build(meshSource.shape);
+                        meshSource.shape.setMeshes(sourceMeshes);
+                    }
+                    meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : meshBuilder.build(shape);
+                }
+                else {
+                    meshes = meshBuilder.build(shape);
+                }
                 shape.setMeshes(meshes);
             }
             const shapeType = shape.getType();
@@ -71,7 +83,18 @@ export function renderSceneRollback(scene, rollbackIndex) {
             for (const shape of sceneShapes) {
                 let meshes = shape.getMeshes();
                 if (!meshes) {
-                    meshes = meshBuilder.build(shape);
+                    const meshSource = shape.getMeshSource();
+                    if (meshSource) {
+                        let sourceMeshes = meshSource.shape.getMeshes();
+                        if (!sourceMeshes) {
+                            sourceMeshes = meshBuilder.build(meshSource.shape);
+                            meshSource.shape.setMeshes(sourceMeshes);
+                        }
+                        meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : meshBuilder.build(shape);
+                    }
+                    else {
+                        meshes = meshBuilder.build(shape);
+                    }
                     shape.setMeshes(meshes);
                 }
                 renderedSceneShapes.push({
@@ -219,7 +242,5 @@ export function renderScene(scene) {
     for (const object of sceneObjects) {
         renderSceneObject(object, scene, buildDurations.get(object));
     }
-    const result = scene.getRenderedObjects();
-    console.table(result);
     return scene;
 }

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

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

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

@@ -0,0 +1,147 @@
+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 draft from "../../core/draft.js";
+import select from "../../core/select.js";
+import { rect } 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("draft", () => {
+    setupOC();
+    describe("draft with implicit selection", () => {
+        it("should apply draft to the last selected face", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid).toBeDefined();
+        });
+        it("should change the bounding box when drafting a side face", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // 5 deg draft over 80mm height: tan(5°) * 80 ≈ 7mm extension
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+        });
+        it("should change volume compared to original box", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(5);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const props = ShapeProps.getProperties(solid.getShape());
+            const originalVolume = 100 * 100 * 80;
+            expect(Math.abs(props.volumeMm3 - originalVolume)).toBeGreaterThan(1000);
+        });
+    });
+    describe("draft with explicit selection", () => {
+        it("should apply draft using e.sideFaces()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(80);
+            draft(5, e.sideFaces());
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            expect(solid).toBeDefined();
+        });
+        it("should apply draft using explicit select()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            const sel = select(face().onPlane("front"));
+            draft(5, sel);
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+    });
+    describe("draft angle effect", () => {
+        it("should produce larger extension with 10 degrees than 3 degrees", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(10);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // tan(10°) * 80 ≈ 14.1mm
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(110);
+        });
+        it("should produce smaller extension with 3 degrees", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            select(face().onPlane("front"));
+            draft(3);
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // tan(3°) * 80 ≈ 4.2mm
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+            expect(bbox.maxY - bbox.minY).toBeLessThan(110);
+        });
+    });
+    describe("draft removes selection shapes", () => {
+        it("should remove the face selection after drafting", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(80);
+            const sel = select(face().onPlane("front"));
+            draft(5, sel);
+            render();
+            expect(sel.getShapes()).toHaveLength(0);
+        });
+    });
+    describe("draft on multiple faces", () => {
+        it("should draft all four side faces via sideFaces()", () => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            const e = extrude(80);
+            draft(5, e.sideFaces());
+            const scene = render();
+            const solid = scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(s => s.getType() === "solid");
+            const bbox = ShapeOps.getBoundingBox(solid);
+            // All four sides drafted — bounding box should extend in both X and Y
+            expect(bbox.maxX - bbox.minX).toBeGreaterThan(103);
+            expect(bbox.maxY - bbox.minY).toBeGreaterThan(103);
+        });
+    });
+});

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");
-        });
-    });
 });